grouping mc-capabilities {
list mc-capabilities {
- when "../node-info/node-type = 'rdm'";
key "mc-node-name";
description
- "Capabilities of the media channel associated with a degree or a SRG.";
+ "Capabilities of the media channel associated with a degree SRG, or
+ XPDR (7.1 and above). ";
leaf mc-node-name {
type string;
description
"Name of the node, it has the format of DEGi-TTP or SRGj-PP
- Where i, and j are the degree and SRG numbers respectively";
+ Where i, and j are the degree and SRG numbers respectively.
+ For XPDR type it will have one element in the leaf-list,
+ with name XPDR-mcprofile";
}
leaf slot-width-granularity {
type org-openroadm-common-optical-channel-types:frequency-GHz;
public static final String PP_TOKEN = "PP";
- public static final String SERVICE_TYPE_100GE = "100GE";
+ public static final String SERVICE_TYPE_100GE_T = "100GEt";
+ public static final String SERVICE_TYPE_100GE_M = "100GEm";
public static final String SERVICE_TYPE_OTU4 = "OTU4";
+ public static final String SERVICE_TYPE_OTUC4 = "OTUC4";
public static final String SERVICE_TYPE_400GE = "400GE";
public static final String SERVICE_TYPE_1GE = "1GE";
public static final String SERVICE_TYPE_ODU4 = "ODU4";
+ public static final String SERVICE_TYPE_ODUC4 = "ODUC4";
private StringConstants() {
// hiding the default constructor
import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_1_2_1;
import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_2_2_1;
+import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_7_1;
import java.math.BigDecimal;
import java.util.List;
private final MappingUtils mappingUtils;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl221;
+ private CrossConnectImpl710 crossConnectImpl710;
public CrossConnectImpl(DeviceTransactionManager deviceTransactionManager, MappingUtils mappingUtils,
CrossConnectImpl121 crossConnectImpl121,
- CrossConnectImpl221 crossConnectImpl221) {
+ CrossConnectImpl221 crossConnectImpl221,
+ CrossConnectImpl710 crossConnectImpl710) {
this.mappingUtils = mappingUtils;
this.crossConnectImpl121 = crossConnectImpl121;
this.crossConnectImpl221 = crossConnectImpl221;
+ this.crossConnectImpl710 = crossConnectImpl710;
this.crossConnect = null;
}
return null;
}
+ public List<String> deleteCrossConnect(String nodeId, String connectionNumber) {
+ String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
+ if (OPENROADM_DEVICE_VERSION_7_1.equals(openRoadmVersion)) {
+ return crossConnectImpl710.deleteOtnCrossConnect(nodeId, connectionNumber);
+ }
+ return null;
+ }
+
public List<?> getConnectionPortTrail(String nodeId, String srcTp, String destTp, int lowerSpectralSlotNumber,
int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
@Override
public Optional<String> postOtnCrossConnect(List<String> createdOduInterfaces, Nodes node)
throws OpenRoadmInterfaceException {
- return crossConnectImpl221.postOtnCrossConnect(createdOduInterfaces, node);
+ String openRoadmVersion = mappingUtils.getOpenRoadmVersion(node.getNodeId());
+
+ if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
+ return crossConnectImpl221.postOtnCrossConnect(createdOduInterfaces, node);
+ }
+ else if (OPENROADM_DEVICE_VERSION_7_1.equals(openRoadmVersion)) {
+ return crossConnectImpl710.postOtnCrossConnect(createdOduInterfaces, node);
+ }
+ return Optional.empty();
}
}
--- /dev/null
+/*
+ * Copyright © 2021 AT&T and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.common.crossconnect;
+
+import com.google.common.util.concurrent.FluentFuture;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import org.eclipse.jdt.annotation.NonNull;
+import org.opendaylight.mdsal.common.api.CommitInfo;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
+import org.opendaylight.transportpce.common.Timeouts;
+import org.opendaylight.transportpce.common.device.DeviceTransaction;
+import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.OduConnection.Direction;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.OrgOpenroadmDevice;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduConnectionBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduConnectionKey;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.otn.renderer.input.Nodes;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class CrossConnectImpl710 {
+
+ private static final Logger LOG = LoggerFactory.getLogger(CrossConnectImpl710.class);
+ private final DeviceTransactionManager deviceTransactionManager;
+
+ public CrossConnectImpl710(DeviceTransactionManager deviceTransactionManager) {
+ this.deviceTransactionManager = deviceTransactionManager;
+ }
+
+ public Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container
+ .org.openroadm.device.OduConnection> getOtnCrossConnect(String deviceId, String connectionNumber) {
+
+ return deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.OPERATIONAL,
+ generateOduConnectionIID(connectionNumber), Timeouts.DEVICE_READ_TIMEOUT,
+ Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+ }
+
+ private InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device
+ .container.org.openroadm.device.OduConnection> generateOduConnectionIID(String connectionNumber) {
+
+ return InstanceIdentifier.create(OrgOpenroadmDevice.class).child(org.opendaylight.yang.gen.v1.http.org
+ .openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduConnection.class,
+ new OduConnectionKey(connectionNumber));
+ }
+
+ public Optional<String> postOtnCrossConnect(List<String> createdOduInterfaces, Nodes node) {
+ String deviceId = node.getNodeId();
+ String srcTp = createdOduInterfaces.get(0);
+ String dstTp = createdOduInterfaces.get(1);
+
+ OduConnectionBuilder oduConnectionBuilder = new OduConnectionBuilder()
+ .setConnectionName(srcTp + "-x-" + dstTp)
+ .setDestination(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.odu.connection
+ .DestinationBuilder().setDstIf(dstTp).build())
+ .setSource(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.odu.connection
+ .SourceBuilder().setSrcIf(srcTp).build())
+ .setDirection(Direction.Bidirectional);
+
+ InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device
+ .container.org.openroadm.device.OduConnection> oduConnectionIID =
+ InstanceIdentifier.create(
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container
+ .OrgOpenroadmDevice.class)
+ .child(org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device
+ .container.org.openroadm.device.OduConnection.class,
+ new OduConnectionKey(oduConnectionBuilder.getConnectionName())
+ );
+
+ Future<Optional<DeviceTransaction>> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId);
+ DeviceTransaction deviceTx;
+ try {
+ Optional<DeviceTransaction> deviceTxOpt = deviceTxFuture.get();
+ if (deviceTxOpt.isPresent()) {
+ deviceTx = deviceTxOpt.get();
+ } else {
+ LOG.error("Device transaction for device {} was not found!", deviceId);
+ return Optional.empty();
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Unable to obtain device transaction for device {}!", deviceId, e);
+ return Optional.empty();
+ }
+
+ // post the cross connect on the device
+ deviceTx.merge(LogicalDatastoreType.CONFIGURATION, oduConnectionIID, oduConnectionBuilder.build());
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ try {
+ commit.get();
+ LOG.info("Otn-connection successfully created: {}-{}", srcTp, dstTp);
+ return Optional.of(srcTp + "-x-" + dstTp);
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Failed to post {}.", oduConnectionBuilder.build(), e);
+ }
+ return Optional.empty();
+
+ }
+
+ public List<String> deleteOtnCrossConnect(String deviceId, String connectionName) {
+ List<String> interfList = new ArrayList<>();
+ Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device
+ .container.org.openroadm.device.OduConnection> otnXc = getOtnCrossConnect(deviceId, connectionName);
+
+ if (otnXc.isPresent()) {
+ interfList.add(otnXc.get().getSource().getSrcIf());
+ interfList.add(otnXc.get().getDestination().getDstIf());
+ } else {
+ LOG.warn("Cross connect {} does not exist, halting delete", connectionName);
+ return null;
+ }
+ Future<Optional<DeviceTransaction>> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId);
+ DeviceTransaction deviceTx;
+ try {
+ Optional<DeviceTransaction> deviceTxOpt = deviceTxFuture.get();
+ if (deviceTxOpt.isPresent()) {
+ deviceTx = deviceTxOpt.get();
+ } else {
+ LOG.error("Device transaction for device {} was not found!", deviceId);
+ return null;
+ }
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.error("Unable to obtain device transaction for device {}!", deviceId, e);
+ return null;
+ }
+
+ deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateOduConnectionIID(connectionName));
+
+ // delete the cross connect on the device
+ deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateOduConnectionIID(connectionName));
+ FluentFuture<? extends @NonNull CommitInfo> commit =
+ deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
+ try {
+ commit.get();
+ LOG.info("Connection {} successfully deleted on {}", connectionName, deviceId);
+ return interfList;
+ } catch (InterruptedException | ExecutionException e) {
+ LOG.warn("Failed to delete {}", connectionName, e);
+ }
+ return null;
+ }
+
+}
public static final int NB_SLOTS_100G = 8;
public static final int NB_SLOTS_400G = 14;
public static final BigDecimal WIDTH_80 = BigDecimal.valueOf(80);
+ public static final BigDecimal WIDTH_75 = BigDecimal.valueOf(75);
public static final BigDecimal WIDTH_40 = BigDecimal.valueOf(40);
public static final BigDecimal SLOT_WIDTH_50 = BigDecimal.valueOf(50);
public static final BigDecimal SLOT_WIDTH_87_5 = BigDecimal.valueOf(87.5);
* Map for associate service type with nb slots.
*/
public static final Map<String, Integer> SPECTRAL_WIDTH_SLOT_NUMBER_MAP = Map.of(
- StringConstants.SERVICE_TYPE_100GE, NB_SLOTS_100G,
+ StringConstants.SERVICE_TYPE_100GE_T, NB_SLOTS_100G,
StringConstants.SERVICE_TYPE_400GE, NB_SLOTS_400G,
StringConstants.SERVICE_TYPE_OTU4, NB_SLOTS_100G);
*/
public static final Map<BigDecimal, BigDecimal> WIDTH_SLOT_WIDTH_MAP = Map.of(
WIDTH_40, SLOT_WIDTH_50,
+ WIDTH_75, SLOT_WIDTH_87_5,
WIDTH_80, SLOT_WIDTH_87_5);
public static final int FIXED_GRID_FREQUENCY_PRECISION = 4;
frequencyWidthTable.put(ServiceRateConstant.RATE_100, ModulationFormat.DpQpsk, String.valueOf(WIDTH_40));
frequencyWidthTable.put(ServiceRateConstant.RATE_200, ModulationFormat.DpQpsk, String.valueOf(WIDTH_80));
frequencyWidthTable.put(ServiceRateConstant.RATE_300, ModulationFormat.DpQam8, String.valueOf(WIDTH_80));
- frequencyWidthTable.put(ServiceRateConstant.RATE_400, ModulationFormat.DpQam16, String.valueOf(WIDTH_80));
+ frequencyWidthTable.put(ServiceRateConstant.RATE_400, ModulationFormat.DpQam16, String.valueOf(WIDTH_75));
return frequencyWidthTable;
}
package org.opendaylight.transportpce.common.mapping;
+
+import java.util.List;
+import java.util.Map;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilities;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
+
public interface PortMapping {
* @return node data if success otherwise null.
*/
Nodes getNode(String nodeId);
+
+ /**
+ * This method allows to update a port-mapping node with odu-connection-map data.
+ * This method is used for an otn xponder in version 7.1, when a device sends a
+ * change-notification advertising controller that odu-switching-pools containers
+ * have been populated inside its configuration
+ * (appears after creation of an OTSI-Group interface).
+ *
+ * @param nodeId
+ * Unique Identifier for the node of interest.
+ * @param ospIID
+ * Instance Identifier of the odu-switching-pools.
+ * @param nbliidMap
+ * Map containing the non-blocking-list number as key,
+ * and the list of Instance Identifier corresponding to each port-list
+ * as value.
+ *
+ * @return Result true/false based on status of operation.
+ */
+ boolean updatePortMappingWithOduSwitchingPools(String nodeId, InstanceIdentifier<OduSwitchingPools> ospIID,
+ Map<Uint16, List<InstanceIdentifier<PortList>>> nbliidMap);
}
import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_2_2_1;
import static org.opendaylight.transportpce.common.StringConstants.OPENROADM_DEVICE_VERSION_7_1;
+import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilitiesKey;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.Nodes;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint16;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
return null;
}
+
+ @Override
+ public boolean updatePortMappingWithOduSwitchingPools(String nodeId, InstanceIdentifier<OduSwitchingPools> ospIID,
+ Map<Uint16, List<InstanceIdentifier<PortList>>> nbliidMap) {
+ OpenroadmNodeVersion openROADMversion = getNode(nodeId).getNodeInfo().getOpenroadmVersion();
+ switch (openROADMversion.getIntValue()) {
+ case 3:
+ return portMappingVersion710.updatePortMappingWithOduSwitchingPools(nodeId, ospIID, nbliidMap);
+ default:
+ LOG.error("Update of the port-mapping [odu-switching-pool] not available for this device version {}",
+ openROADMversion);
+ return false;
+ }
+ }
}
import java.util.stream.Collectors;
import org.eclipse.jdt.annotation.NonNull;
import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
import org.opendaylight.mdsal.binding.api.WriteTransaction;
import org.opendaylight.mdsal.common.api.CommitInfo;
import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilities;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilitiesBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilitiesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mpdr.restrictions.grp.MpdrRestrictionsBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.Nodes;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Info;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.McCapabilityProfile;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.McCapabilityProfileKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.MuxpProfile;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.MuxpProfileKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.Protocols;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.SharedRiskGroup;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.port.Interfaces;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.xponder.XpdrPort;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.PortQual;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.InterfaceType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.Protocols1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.Lldp;
import org.opendaylight.yang.gen.v1.http.org.openroadm.lldp.rev200529.lldp.container.lldp.PortConfig;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.Ports1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.SupportedInterfaceCapability;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.SupportedInterfaceCapabilityKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.capability.rev200529.port.capability.grp.port.capabilities.supported._interface.capability.otn.capability.MpdrClientRestriction;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.binding.KeyedInstanceIdentifier;
import org.opendaylight.yangtools.yang.common.Uint16;
import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
// FIXME: many common pieces of code between PortMapping Versions 121 and 221 and 710
// some mutualization would be helpful
@SuppressWarnings("CPD-START")
}
public boolean createMappingData(String nodeId) {
- LOG.info("{} : OpenROADM version 7.1.0 node - Creating Mapping Data", nodeId);
+ LOG.info("{} : OpenROADM version 7.1 node - Creating Mapping Data", nodeId);
List<Mapping> portMapList = new ArrayList<>();
Map<McCapabilitiesKey, McCapabilities> mcCapabilities = new HashMap<>();
InstanceIdentifier<Info> infoIID = InstanceIdentifier.create(OrgOpenroadmDevice.class).child(Info.class);
LOG.warn("{} : Unable to create mapping for the Xponder", nodeId);
return false;
}
+ // In the case of 7.1 models, even XPDR advertizes mc-capabilities,
+ // hence we need to populate this information into the port-mapping data
+ // Get MC capabilities
+ if (!createMcCapabilitiesList(nodeId, deviceInfo, mcCapabilities)) {
+ // return false if MC capabilites failed
+ LOG.warn("{} : Unable to create MC capabilities", nodeId);
+ return false;
+ }
break;
default:
LOG.error("{} : unknown nodetype - Unable to create mapping", nodeId);
}
}
+ public boolean updatePortMappingWithOduSwitchingPools(String nodeId, InstanceIdentifier<OduSwitchingPools> ospIID,
+ Map<Uint16, List<InstanceIdentifier<PortList>>> nbliidMap) {
+
+ KeyedInstanceIdentifier<Nodes, NodesKey> portMappingNodeIID = InstanceIdentifier.create(Network.class)
+ .child(Nodes.class, new NodesKey(nodeId));
+ Nodes portmappingNode = null;
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ portmappingNode = readTx.read(LogicalDatastoreType.CONFIGURATION, portMappingNodeIID).get().get();
+ } catch (InterruptedException | ExecutionException ex) {
+ LOG.error("Unable to read the port-mapping for nodeId {}", nodeId, ex);
+ }
+ if (portmappingNode == null) {
+ return false;
+ }
+ Map<MappingKey, Mapping> mappings = portmappingNode.nonnullMapping();
+
+ OduSwitchingPools osp = deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL,
+ ospIID, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT).get();
+ Uint16 ospNumber = osp.getSwitchingPoolNumber();
+ Map<SwitchingPoolLcpKey, SwitchingPoolLcp> splMap = new HashMap(portmappingNode.nonnullSwitchingPoolLcp());
+ SwitchingPoolLcpBuilder splBldr = splMap.containsKey(new SwitchingPoolLcpKey(ospNumber))
+ ? new SwitchingPoolLcpBuilder(splMap.get(new SwitchingPoolLcpKey(ospNumber)))
+ : new SwitchingPoolLcpBuilder().setSwitchingPoolNumber(ospNumber)
+ .setSwitchingPoolType(osp.getSwitchingPoolType());
+ Map<NonBlockingListKey, NonBlockingList> nblMap = new HashMap<>();
+ for (Entry<Uint16, List<InstanceIdentifier<PortList>>> entry : nbliidMap.entrySet()) {
+ Uint32 interconnectBw = osp.getNonBlockingList().get(new
+ org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org
+ .openroadm.device.odu.switching.pools.NonBlockingListKey(entry.getKey()))
+ .getInterconnectBandwidth();
+ NonBlockingList nbl = createNonBlockingList(splBldr, interconnectBw, entry, mappings, nodeId);
+ if (nbl == null) {
+ return false;
+ }
+ nblMap.put(nbl.key(), nbl);
+ }
+ SwitchingPoolLcp switchingPoolLcp = splBldr
+ .setNonBlockingList(nblMap)
+ .build();
+ splMap.put(switchingPoolLcp.key(), switchingPoolLcp);
+ List<SwitchingPoolLcp> switchingPoolList = new ArrayList<>(splMap.values());
+ postPortMapping(nodeId, null, null, null, switchingPoolList, null);
+ return true;
+ }
+
+ private NonBlockingList createNonBlockingList(SwitchingPoolLcpBuilder splBldr, Uint32 interconnectBw,
+ Entry<Uint16, List<InstanceIdentifier<PortList>>> entry, Map<MappingKey, Mapping> mappings, String nodeId) {
+ NonBlockingListBuilder nblBldr;
+ if (splBldr.getNonBlockingList() != null
+ && splBldr.getNonBlockingList().containsKey(new NonBlockingListKey(entry.getKey()))) {
+ nblBldr = new NonBlockingListBuilder(splBldr.getNonBlockingList()
+ .get(new NonBlockingListKey(entry.getKey())));
+ } else {
+ nblBldr = new NonBlockingListBuilder()
+ .setNblNumber(entry.getKey())
+ .setInterconnectBandwidth(interconnectBw);
+ }
+ List<String> lcpList = nblBldr.getLcpList() != null ? nblBldr.getLcpList() : new ArrayList<>();
+ for (InstanceIdentifier<PortList> id : entry.getValue()) {
+ PortList portList = deviceTransactionManager.getDataFromDevice(nodeId, LogicalDatastoreType.OPERATIONAL,
+ id, Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT).get();
+ String circuitPackName = portList.getCircuitPackName();
+ String portName = portList.getPortName();
+ String lcp = getLcpFromCpAndPort(mappings, circuitPackName, portName);
+ if (lcp != null && !lcpList.contains(lcp)) {
+ lcpList.add(lcp);
+ } else {
+ return null;
+ }
+ }
+ nblBldr.setLcpList(lcpList);
+ return nblBldr.build();
+ }
+
private boolean createXpdrPortMapping(String nodeId, List<Mapping> portMapList) {
// Creating for Xponder Line and Client Ports
InstanceIdentifier<OrgOpenroadmDevice> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class);
if (interfaceType.equals(OpticalTransport.class)) {
mpBldr.setSupportingOts(interfaces.getInterfaceName());
}
- if (interfaceType.equals(OtnOdu.class)) {
+ String interfaceName = interfaces.getInterfaceName();
+ if (interfaceType.equals(OtnOdu.class)
+ && (interfaceName.substring(interfaceName.lastIndexOf("-") + 1)
+ .equals("ODU"))) {
mpBldr.setSupportingOdu4(interfaces.getInterfaceName());
}
+ if ((interfaceType.equals(OtnOdu.class))
+ && (interfaceName.substring(interfaceName.lastIndexOf("-") + 1)
+ .equals("ODUC4"))) {
+ mpBldr.setSupportingOduc4(interfaces.getInterfaceName());
+ }
+
} catch (OpenRoadmInterfaceException ex) {
LOG.warn("{} : Error while getting interface {} - ",
nodeId, interfaces.getInterfaceName(), ex);
.SupportedIfCapability>> supportedIntf = new ArrayList<>();
Map<SupportedInterfaceCapabilityKey, SupportedInterfaceCapability> supIfCapMap = port
.augmentation(Ports1.class).getPortCapabilities().nonnullSupportedInterfaceCapability();
+ SupportedInterfaceCapability sic1 = null;
for (SupportedInterfaceCapability sic : supIfCapMap.values()) {
supportedIntf.add(sic.getIfCapType());
+ sic1 = sic;
+ }
+ if (port.getPortQual() == PortQual.SwitchClient
+ && !sic1.getOtnCapability().getMpdrClientRestriction().isEmpty()) {
+ List<MpdrClientRestriction> mpdrClientRestriction = sic1.getOtnCapability().getMpdrClientRestriction();
+ // Here we assume all the supported-interfaces has the support same rates, and the
+ // trib-slot numbers are assumed to be the same
+ String mxpProfileName = mpdrClientRestriction.get(0).getMuxpProfileName().get(0);
+ // From this muxponder-profile get the min-trib-slot and the max-trib-slot
+ LOG.info("{}: Muxp-profile used for trib information {}", nodeId, mxpProfileName);
+ // This provides the tribSlot information from muxProfile
+ List<OpucnTribSlotDef> minMaxOpucnTribSlots = getOpucnTribSlots(nodeId, mxpProfileName);
+ mpBldr.setMpdrRestrictions(
+ new MpdrRestrictionsBuilder()
+ .setMinTribSlot(minMaxOpucnTribSlots.get(0))
+ .setMaxTribSlot(minMaxOpucnTribSlots.get(1))
+ .build());
}
mpBldr.setSupportedInterfaceCapability(supportedIntf);
}
return mpBldr.build();
}
+ private ArrayList<OpucnTribSlotDef> getOpucnTribSlots(String deviceId, String mxpProfileName) {
+ ArrayList<OpucnTribSlotDef> minMaxOpucnTribSlots = new ArrayList<>(2);
+
+ LOG.info("{} : Getting Min/Max Trib-slots from {}", deviceId, mxpProfileName);
+ InstanceIdentifier<MuxpProfile> deviceIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
+ .child(MuxpProfile.class, new MuxpProfileKey(mxpProfileName));
+
+ Optional<MuxpProfile> muxpProfileObject = this.deviceTransactionManager.getDataFromDevice(deviceId,
+ LogicalDatastoreType.OPERATIONAL, deviceIID,
+ Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
+
+ List<OpucnTribSlotDef> ntwHoOduOpucnTribSlots = muxpProfileObject.get().getNetworkHoOduOpucnTribSlots();
+ // Sort the tib-slots in ascending order and pick min and max
+ List<OpucnTribSlotDef> sortedNtwHoOduOpucnTribSlots = ntwHoOduOpucnTribSlots.stream().sorted(
+ Comparator.comparingDouble(x -> Double.parseDouble(
+ x.getValue().substring(x.getValue().lastIndexOf('.') + 1))))
+ .collect(Collectors.toList());
+ minMaxOpucnTribSlots.add(sortedNtwHoOduOpucnTribSlots.get(0));
+ minMaxOpucnTribSlots.add(sortedNtwHoOduOpucnTribSlots.get(sortedNtwHoOduOpucnTribSlots.size() - 1));
+ // LOG.info("Min, Max trib slot list {}", minMaxOpucnTribSlots);
+ return minMaxOpucnTribSlots;
+ }
+
private Ports getPort2(Ports port, String nodeId, String circuitPackName, StringBuilder circuitPackName2,
//circuitPackName2 will be updated by reference contrary to circuitPackName
List<CircuitPacks> circuitPackList, Map<String, String> lcpMap) {
private boolean createMcCapabilitiesList(String nodeId, Info deviceInfo,
Map<McCapabilitiesKey, McCapabilities> mcCapabilitiesMap) {
- Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
- List<SharedRiskGroup> srgs = getSrgs(nodeId, deviceInfo);
- mcCapabilitiesMap.putAll(getMcCapabilities(degrees, srgs, deviceInfo, nodeId));
+ if (deviceInfo.getNodeType() == NodeTypes.Rdm) {
+ Map<Integer, Degree> degrees = getDegreesMap(nodeId, deviceInfo);
+ List<SharedRiskGroup> srgs = getSrgs(nodeId, deviceInfo);
+ mcCapabilitiesMap.putAll(getMcCapabilities(degrees, srgs, deviceInfo, nodeId));
+ } else if ((deviceInfo.getNodeType() == NodeTypes.Xpdr)) {
+ Map<McCapabilityProfileKey, McCapabilityProfile> mcProfileXpdr = getMcCapabilityProfiles(nodeId,
+ deviceInfo);
+ if (mcProfileXpdr.size() > 1) {
+ LOG.warn("Re-check the mc-capability-profiles for XPDR port-mapping");
+ }
+ // Typically for a XPDR there will be only one mc-capability-profile
+ for (Map.Entry<McCapabilityProfileKey, McCapabilityProfile> mcCapProfile : mcProfileXpdr.entrySet()) {
+ String mcNodeName = "XPDR" + "-" + "mcprofile";
+ McCapabilitiesBuilder mcCapabilitiesBuilder = new McCapabilitiesBuilder()
+ .withKey(new McCapabilitiesKey(mcNodeName))
+ .setMcNodeName(mcNodeName);
+ mcCapabilitiesBuilder
+ .setCenterFreqGranularity(mcCapProfile.getValue().getCenterFreqGranularity())
+ .setSlotWidthGranularity(mcCapProfile.getValue().getSlotWidthGranularity());
+ // Build and add to the Map
+ mcCapabilitiesMap.put(mcCapabilitiesBuilder.key(), mcCapabilitiesBuilder.build());
+ LOG.info("Finished building mc-capability profile for XPDR {}", nodeId);
+ // Since we only have one mc-profile for XPDR, we can break the for-loop
+ break;
+ }
+
+ }
return true;
}
return nodeInfoBldr.build();
}
+ private String getLcpFromCpAndPort(Map<MappingKey, Mapping> mappings, String cpName, String portName) {
+ for (Mapping mapping : mappings.values()) {
+ if (cpName.equals(mapping.getSupportingCircuitPackName())
+ && portName.equals(mapping.getSupportingPort())) {
+ return mapping.getLogicalConnectionPoint();
+ }
+ }
+ return null;
+ }
}
<argument ref="deviceTransactionManager" />
</bean>
+ <bean id="crossConnect710" class="org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710" >
+ <argument ref="deviceTransactionManager" />
+ </bean>
+
<bean id="crossConnectImpl" class="org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl" >
<argument ref="deviceTransactionManager" />
<argument ref="mappingUtils" />
<argument ref="crossConnect121" />
<argument ref="crossConnect221" />
+ <argument ref="crossConnect710" />
</bean>
<service ref="deviceTransactionManager" interface="org.opendaylight.transportpce.common.device.DeviceTransactionManager" />
private static DeviceTransactionManager deviceTransactionManager;
private CrossConnectImpl121 crossConnectImpl121 = null;
private CrossConnectImpl221 crossConnectImpl221 = null;
+ private CrossConnectImpl710 crossConnectImpl710 = null;
private MappingUtils mappingUtils = null;
@Before
deviceTransactionManager = mock(DeviceTransactionManager.class);
crossConnectImpl121 = mock(CrossConnectImpl121.class);
crossConnectImpl221 = mock(CrossConnectImpl221.class);
+ crossConnectImpl710 = mock(CrossConnectImpl710.class);
mappingUtils = mock(MappingUtils.class);
crossConnectImpl =
- new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121, crossConnectImpl221);
+ new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121,
+ crossConnectImpl221, crossConnectImpl710);
}
@Before
@Test
public void getWidthFromRateAndModulationFormatTest() {
- assertEquals("Width should be 80", new FrequencyGHz(GridConstant.WIDTH_80),
+ assertEquals("Width should be 75", new FrequencyGHz(GridConstant.WIDTH_75),
GridUtils.getWidthFromRateAndModulationFormat(ServiceRateConstant.RATE_400,
ModulationFormat.DpQam16));
}
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
- <artifactId>odl-restconf-all</artifactId>
+ <artifactId>odl-restconf</artifactId>
<classifier>features</classifier>
<type>xml</type>
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
- <artifactId>odl-netconf-all</artifactId>
+ <artifactId>odl-netconf-connector</artifactId>
<classifier>features</classifier>
<type>xml</type>
</dependency>
<dependency>
<groupId>org.opendaylight.netconf</groupId>
- <artifactId>odl-netconf-connector-all</artifactId>
+ <artifactId>odl-netconf-topology</artifactId>
<classifier>features</classifier>
<type>xml</type>
</dependency>
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
// Adding OTN interface
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererServiceImpl;
import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping, openRoadmInterfaces);
OpenRoadmOtnInterface221 openRoadmOtnInterface221 = new OpenRoadmOtnInterface221(portMapping,
openRoadmInterfaces);
+ OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping,
+ openRoadmInterfaces);
return new OpenRoadmInterfaceFactory(mappingUtils, openRoadmInterface121, openRoadmInterface221,
- openRoadmInterface710, openRoadmOtnInterface221);
+ openRoadmInterface710, openRoadmOtnInterface221, openRoadmOtnInterface710);
}
private PortMapping initPortMapping(LightyServices lightyServices, OpenRoadmInterfaces openRoadmInterfaces) {
private CrossConnect initCrossConnect(MappingUtils mappingUtils) {
CrossConnectImpl121 crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
CrossConnectImpl221 crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager);
- return new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121, crossConnectImpl221);
+ CrossConnectImpl710 crossConnectImpl710 = new CrossConnectImpl710(deviceTransactionManager);
+ return new CrossConnectImpl(deviceTransactionManager, mappingUtils, crossConnectImpl121, crossConnectImpl221,
+ crossConnectImpl710);
}
}
.$YangModuleInfoImpl.getInstance(),
org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.$YangModuleInfoImpl
.getInstance(),
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.$YangModuleInfoImpl.getInstance(),
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.$YangModuleInfoImpl.getInstance(),
org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.iana._if.type.rev170119.$YangModuleInfoImpl
.getInstance(),
package org.opendaylight.transportpce.networkmodel.listeners;
+import java.util.ArrayList;
+import java.util.HashMap;
import java.util.LinkedList;
+import java.util.List;
+import java.util.Map;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.ChangeNotification;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.change.notification.Edit;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.pack.Ports;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.circuit.packs.CircuitPacks;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.OduSwitchingPools;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.NonBlockingList;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.org.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
+import org.opendaylight.yangtools.yang.common.Uint16;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
@Override
@SuppressWarnings("unchecked")
public void onChangeNotification(ChangeNotification notification) {
+ LOG.debug("device71 notification received = {}", notification);
if (notification.getEdit() == null) {
LOG.warn("unable to handle {} notificatin received - list of edit is null", ChangeNotification.QNAME);
return;
}
+ Map<Uint16, List<InstanceIdentifier<PortList>>> nbliidMap = new HashMap<>();
+ InstanceIdentifier<OduSwitchingPools> ospIID = null;
for (Edit edit : notification.getEdit()) {
// 1. Detect the org-openroadm-device object modified
+ LinkedList<PathArgument> path = new LinkedList<>();
switch (edit.getTarget().getTargetType().getSimpleName()) {
case "Ports":
- LinkedList<PathArgument> path = new LinkedList<>();
edit.getTarget().getPathArguments().forEach(p -> path.add(p));
InstanceIdentifier<Ports> portIID = (InstanceIdentifier<Ports>) InstanceIdentifier
.create(path);
Thread thread = new Thread(handleNetconfEvent);
thread.start();
break;
+ case "OduSwitchingPools":
+ LOG.info("odu-switching-pools modified on device {}", nodeId);
+ edit.getTarget().getPathArguments().forEach(p -> path.add(p));
+ ospIID = (InstanceIdentifier<OduSwitchingPools>) InstanceIdentifier.create(path);
+ break;
+ case "PortList":
+ edit.getTarget().getPathArguments().forEach(p -> path.add(p));
+ InstanceIdentifier<PortList> plIID = (InstanceIdentifier<PortList>) InstanceIdentifier.create(path);
+ path.removeLast();
+ InstanceIdentifier<NonBlockingList> nblIID =
+ (InstanceIdentifier<NonBlockingList>) InstanceIdentifier.create(path);
+ Uint16 nblNb = InstanceIdentifier.keyOf(nblIID).getNblNumber();
+ List<InstanceIdentifier<PortList>> iidList = nbliidMap.containsKey(nblNb)
+ ? nbliidMap.get(nblNb) : new ArrayList<>();
+ iidList.add(plIID);
+ nbliidMap.put(nblNb, iidList);
+ break;
default:
LOG.debug("modification of type {} not managed yet", edit.getTarget().getTargetType());
break;
}
}
+ if (!nbliidMap.isEmpty() && ospIID != null) {
+ InstanceIdentifier<OduSwitchingPools> id = ospIID;
+ Runnable handleNetconfEvent = new Runnable() {
+ @Override
+ public void run() {
+ portMapping.updatePortMappingWithOduSwitchingPools(nodeId, id, nbliidMap);
+ LOG.info("{} : swiching-pool data updated", nodeId);
+ }
+ };
+ Thread thread = new Thread(handleNetconfEvent);
+ thread.start();
+ }
}
@Override
import java.util.List;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
/**
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Link1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev191129.SwitchingPoolTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPool;
import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPoolBuilder;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
private static List<Link> initialiseOtnLinks(String nodeA, String tpA, String nodeZ, String tpZ,
OtnLinkType linkType, String linkIdPrefix) {
List<Link> links = new ArrayList<>();
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.Link1 tpceLink1
- = new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.Link1Builder()
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1 tpceLink1
+ = new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1Builder()
.setOtnLinkType(linkType).build();
Link1 otnLink1 = new Link1Builder()
.setAvailableBandwidth(Uint32.valueOf(100000))
LOG.warn("mapping {} of node {} has no if-cap-type", mapping.getLogicalConnectionPoint(),
node.getNodeId());
}
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1Builder tpceTp1Bldr =
- new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1Builder();
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder tpceTp1Bldr =
+ new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder();
TpId tpId = new TpId(mapping.getLogicalConnectionPoint());
setclientNwTpAttr(tpMap, node, tpId, tpType, otnTp1Bldr.build(), tpceTp1Bldr, mapping);
}
private static void setclientNwTpAttr(Map<TerminationPointKey, TerminationPoint> tpMap, OtnTopoNode node, TpId tpId,
OpenroadmTpType tpType, TerminationPoint1 otnTp1,
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1Builder tpceTp1Bldr,
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder tpceTp1Bldr,
Mapping mapping) {
switch (tpType) {
case XPONDERNETWORK:
}
private static TerminationPoint buildIetfTp(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1Builder tpceTp1Bldr,
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder tpceTp1Bldr,
TerminationPoint1 otnTp1, OpenroadmTpType tpType, TpId tpId,
Map<SupportingTerminationPointKey, SupportingTerminationPoint> supportTpMap, Mapping mapping) {
.setOperationalState(TopologyUtils.setNetworkOperState(m.getPortOperState()));
if (m.getPortQual().equals("xpdr-network")) {
ocnTp1Bldr.setTpType(OpenroadmTpType.XPONDERNETWORK);
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1 tpceTp1 =
- new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1Builder()
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1 tpceTp1 =
+ new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder()
.setAssociatedConnectionMapPort(m.getConnectionMapLcp()).build();
ietfTpBldr
.addAugmentation(ocnTp1Bldr.build())
tpMap.put(ietfTp.key(),ietfTp);
} else if (m.getPortQual().equals("xpdr-client")) {
ocnTp1Bldr.setTpType(OpenroadmTpType.XPONDERCLIENT);
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1 tpceTp1 =
- new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1Builder()
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1 tpceTp1 =
+ new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1Builder()
.setAssociatedConnectionMapPort(m.getConnectionMapLcp()).build();
ietfTpBldr
.addAugmentation(ocnTp1Bldr.build())
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If10GEODU2e;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCH;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCHOTU4ODU4;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.node.SupportingNode;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
"otn link type should be OTU4",
OtnLinkType.OTU4,
sortedLinks.get(0).augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.Link1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1.class)
.getOtnLinkType());
}
OtnLinkType.ODTU4,
sortedLinks.get(0)
.augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.Link1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1.class)
.getOtnLinkType());
assertEquals("list of TPs should contain 2 updated TPs", 2, topoShard.getTps().size());
assertEquals("XPDR1-CLIENT1", tps.get(0).getTpId().getValue());
assertEquals(OpenroadmTpType.XPONDERCLIENT, tps.get(0).augmentation(TerminationPoint1.class).getTpType());
assertEquals("XPDR1-NETWORK1", tps.get(0).augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
.getAssociatedConnectionMapPort());
assertEquals("XPDR1-NETWORK1", tps.get(2).getTpId().getValue());
assertEquals(OpenroadmTpType.XPONDERNETWORK, tps.get(2).augmentation(TerminationPoint1.class).getTpType());
assertEquals("XPDR1-CLIENT1", tps.get(2).augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
.getAssociatedConnectionMapPort());
}
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCHOTU4ODU4;
import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPool;
import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev200529.xpdr.otn.tp.attributes.OdtuTpnPoolBuilder;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
.setUsedBandwidth(Uint32.valueOf(100000 - availBW))
.build())
.addAugmentation(
- new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.Link1Builder()
+ new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1Builder()
.setOtnLinkType(type)
.build())
.build();
.setUsedBandwidth(Uint32.valueOf(100000 - availBW))
.build())
.addAugmentation(
- new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.Link1Builder()
+ new org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1Builder()
.setOtnLinkType(type)
.build())
.build();
Timeouts.DEVICE_READ_TIMEOUT, Timeouts.DEVICE_READ_TIMEOUT_UNIT);
if (portObject.isPresent()) {
Ports port = portObject.get();
- if (port.getTransponderPort().getPortPowerCapabilityMaxTx() != null) {
+ if (port.getTransponderPort() != null && port.getTransponderPort().getPortPowerCapabilityMaxTx() != null) {
powerRangeMap.put("MaxTx", port.getTransponderPort().getPortPowerCapabilityMaxTx().getValue()
.doubleValue());
powerRangeMap.put("MinTx", port.getTransponderPort().getPortPowerCapabilityMinTx().getValue()
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
private OlmPowerServiceRpcImpl olmPowerServiceRpc;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl22;
+ private CrossConnectImpl710 crossConnectImpl710;
private MappingUtils mappingUtils;
private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22;
this.deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointService, 3000);
this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager);
+ this.crossConnectImpl710 = new CrossConnectImpl710(deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
- this.crossConnectImpl22);
+ this.crossConnectImpl22, this.crossConnectImpl710);
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager);
this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
private PowerMgmt powerMgmt;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl22;
+ private CrossConnectImpl710 crossConnectImpl710;
private MappingUtils mappingUtils;
private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22;
this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
- this.crossConnectImpl22);
+ this.crossConnectImpl22, this.crossConnectImpl710);
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager);
this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
private PowerMgmt powerMgmt;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl22;
+ private CrossConnectImpl710 crossConnectImpl710;
private MappingUtils mappingUtils;
private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22;
this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
- this.crossConnectImpl22);
+ this.crossConnectImpl22, this.crossConnectImpl710);
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager);
this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
private PowerMgmt powerMgmt;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl22;
+ private CrossConnectImpl710 crossConnectImpl710;
private MappingUtils mappingUtils;
private OpenRoadmInterfacesImpl121 openRoadmInterfacesImpl121;
private OpenRoadmInterfacesImpl221 openRoadmInterfacesImpl22;
this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
this.crossConnectImpl22 = new CrossConnectImpl221(deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
- this.crossConnectImpl22);
+ this.crossConnectImpl22, this.crossConnectImpl710);
this.openRoadmInterfacesImpl121 = new OpenRoadmInterfacesImpl121(deviceTransactionManager);
this.openRoadmInterfacesImpl22 = new OpenRoadmInterfacesImpl221(deviceTransactionManager);
this.openRoadmInterfacesImpl710 = new OpenRoadmInterfacesImpl710(deviceTransactionManager);
contact
"TransportPCE team";
+ revision 2021-05-11 {
+ description "Update otn-link-type enum for higher rates";
+ }
revision 2020-10-19 {
description "Update to 7.1.0 Openroadm network and common models";
}
enum "ODU0" {
value 4;
}
+ enum "OTUC4" {
+ value 5;
+ }
+ enum "ODUC4" {
+ value 6;
+ }
}
}
.setAToZ(atozMap);
switch (rc.getServiceType()) {
case StringConstants.SERVICE_TYPE_400GE:
- case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ case StringConstants.SERVICE_TYPE_100GE_T:
case StringConstants.SERVICE_TYPE_OTU4:
atoZDirectionBldr.setAToZMaxFrequency(new FrequencyTHz(rc.getMaxFreq()));
atoZDirectionBldr.setAToZMinFrequency(new FrequencyTHz(rc.getMinFreq()));
atoZDirectionBldr.setAToZWavelengthNumber(Uint32.valueOf(rc.getResultWavelength()));
break;
+ case StringConstants.SERVICE_TYPE_100GE_M:
case StringConstants.SERVICE_TYPE_10GE:
case StringConstants.SERVICE_TYPE_1GE:
case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC4:
if (rc.getResultTribSlot() != null && rc.getResultTribPort() != null) {
@SuppressWarnings("unchecked")
List<Uint16> tribSlotList = (List<Uint16>) rc.getResultTribSlot().values().toArray()[0];
.setZToA(ztoaMap);
switch (rc.getServiceType()) {
case StringConstants.SERVICE_TYPE_400GE:
- case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ case StringConstants.SERVICE_TYPE_100GE_T:
case StringConstants.SERVICE_TYPE_OTU4:
ztoADirectionBldr.setZToAMaxFrequency(new FrequencyTHz(rc.getMaxFreq()));
ztoADirectionBldr.setZToAMinFrequency(new FrequencyTHz(rc.getMinFreq()));
ztoADirectionBldr.setZToAWavelengthNumber(Uint32.valueOf(rc.getResultWavelength()));
break;
+ case StringConstants.SERVICE_TYPE_100GE_M:
case StringConstants.SERVICE_TYPE_10GE:
case StringConstants.SERVICE_TYPE_1GE:
case StringConstants.SERVICE_TYPE_ODU4:
shortestPathAtoZ = new ArrayList<>(pathAtoZ);
switch (serviceType) {
- case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_100GE_T:
+ case StringConstants.SERVICE_TYPE_OTUC4:
case StringConstants.SERVICE_TYPE_400GE:
case StringConstants.SERVICE_TYPE_OTU4:
LOG.info(
SpectrumAssignment spectrumAssignment = null;
//variable to deal with 1GE (Nb=1) and 10GE (Nb=10) cases
switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_OTUC4:
case StringConstants.SERVICE_TYPE_400GE:
spectralWidthSlotNumber = GridConstant.SPECTRAL_WIDTH_SLOT_NUMBER_MAP
.getOrDefault(serviceType, GridConstant.NB_SLOTS_400G);
//fallthrough
- case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_100GE_T:
case StringConstants.SERVICE_TYPE_OTU4:
spectrumAssignment = getSpectrumAssignment(path,
allPceNodes, spectralWidthSlotNumber);
pceResult.setRC(ResponseCodes.RESPONSE_OK);
pceResult.setLocalCause(PceResult.LocalCause.NONE);
break;
+ case StringConstants.SERVICE_TYPE_100GE_M:
case StringConstants.SERVICE_TYPE_10GE:
- tribSlotNb = 8;
+ tribSlotNb = StringConstants.SERVICE_TYPE_10GE.equals(serviceType) ? 8 : 20;
//fallthrough
case StringConstants.SERVICE_TYPE_1GE:
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
}
break;
case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC4:
pceResult.setRC(ResponseCodes.RESPONSE_OK);
- LOG.info("In PostAlgoPathValidator: ODU4 path found {}", path);
+ LOG.info("In PostAlgoPathValidator: ODU4/ODUC4 path found {}", path);
break;
default:
pceResult.setRC(ResponseCodes.RESPONSE_FAILED);
if (allPceNodes.containsKey(edge.link().getSourceId())) {
PceNode pceNode = allPceNodes.get(edge.link().getSourceId());
LOG.info("Processing PCE node {}", pceNode);
- if (StringConstants.OPENROADM_DEVICE_VERSION_1_2_1.equals(pceNode.getVersion())
- || pceNode.getSlotWidthGranularity().compareTo(GridConstant.SLOT_WIDTH_50) == 0) {
+ if (StringConstants.OPENROADM_DEVICE_VERSION_1_2_1.equals(pceNode.getVersion())) {
LOG.info("Node {}: version is {} and slot width granularity is {} -> fixed grid mode",
- pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity());
+ pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity());
+ isFlexGrid = false;
+ }
+ if ((pceNode.getSlotWidthGranularity().equals(GridConstant.SLOT_WIDTH_50))
+ && (pceNode.getCentralFreqGranularity().equals(GridConstant.SLOT_WIDTH_50))) {
+ LOG.info("Node {}: version is {} with slot width granularity {} and central "
+ + "frequency granularity is {} -> fixed grid mode",
+ pceNode.getNodeId(), pceNode.getVersion(), pceNode.getSlotWidthGranularity(),
+ pceNode.getCentralFreqGranularity());
isFlexGrid = false;
}
pceNodeFreqMap = pceNode.getBitSetData();
import org.opendaylight.transportpce.common.network.NetworkTransactionService;
import org.opendaylight.transportpce.pce.constraints.PceConstraints;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.PathComputationRequestInput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mc.capabilities.McCapabilities;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Link1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.PortQual;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmNodeType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
serviceRate = input.getServiceAEnd().getServiceRate().toJava();
LOG.info("parseInput: A and Z :[{}] and [{}]", anodeId, znodeId);
- if (!(serviceFormatA.equals(serviceFormatZ))) {
- LOG.info("parseInput: different service format for A and Z not handled, will use service format from Aend");
- } else if (serviceRate == 100L) {
- switch (serviceFormatA) {
- case "Ethernet":
- case "OC":
- serviceType = StringConstants.SERVICE_TYPE_100GE;
- break;
- case "OTU":
- serviceType = StringConstants.SERVICE_TYPE_OTU4;
- break;
- case "ODU":
- serviceType = StringConstants.SERVICE_TYPE_ODU4;
- break;
- default:
- LOG.debug("parseInput: unsupported service type: Format {} Rate 100L", serviceFormatA);
- break;
- }
- //switch(serviceRate) may seem a better option at first glance.
- //But switching on Long or long is not directly possible in Java.
- //And casting to int bumps the limit here.
- //Passing by ENUM or String are possible alternatives.
- //Maybe HashMap and similar options should also be considered here.
- } else if ("Ethernet".equals(serviceFormatA)) {
- //only rate 100L is currently supported except in Ethernet
- if (serviceRate == 400L) {
- serviceType = StringConstants.SERVICE_TYPE_400GE;
- } else if (serviceRate == 10L) {
- serviceType = StringConstants.SERVICE_TYPE_10GE;
- } else if (serviceRate == 1L) {
- serviceType = StringConstants.SERVICE_TYPE_1GE;
- } else {
- LOG.debug("parseInput: unsupported service type: Format Ethernet Rate {}", serviceRate);
- }
- } else {
- LOG.debug("parseInput: unsupported service type: Format {} Rate {}",
- serviceFormatA, serviceRate);
- }
+
+ setServiceType();
if (StringConstants.SERVICE_TYPE_ODU4.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_ODUC4.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_100GE_M.equals(serviceType)
|| StringConstants.SERVICE_TYPE_10GE.equals(serviceType)
|| StringConstants.SERVICE_TYPE_1GE.equals(serviceType)) {
anodeId = input.getServiceAEnd().getTxDirection().getPort().getPortDeviceName();
return true;
}
+ private void setServiceType() {
+ if ("Ethernet".equals(serviceFormatA)) {
+ switch (serviceRate.intValue()) {
+ case 1:
+ serviceType = StringConstants.SERVICE_TYPE_1GE;
+ break;
+ case 10:
+ serviceType = StringConstants.SERVICE_TYPE_10GE;
+ break;
+ case 100:
+ serviceType = StringConstants.SERVICE_TYPE_100GE_T;
+ if (NodeTypes.Xpdr.equals(portMapping.getNode(input.getServiceAEnd().getNodeId())
+ .getNodeInfo().getNodeType())) {
+ if (input.getServiceAEnd().getTxDirection() != null
+ && input.getServiceAEnd().getTxDirection().getPort() != null
+ && input.getServiceAEnd().getTxDirection().getPort().getPortName() != null) {
+ String lcp = input.getServiceAEnd().getTxDirection().getPort().getPortName();
+ if (portMapping.getMapping(input.getServiceAEnd().getNodeId(), lcp) != null) {
+ Mapping mapping = portMapping.getMapping(input.getServiceAEnd().getNodeId(), lcp);
+ if (PortQual.SwitchClient.getName().equals(mapping.getPortQual())) {
+ serviceType = StringConstants.SERVICE_TYPE_100GE_M;
+ }
+ }
+ }
+ }
+ break;
+ case 400:
+ serviceType = StringConstants.SERVICE_TYPE_400GE;
+ break;
+ default:
+ LOG.warn("Invalid service-rate {}", serviceRate);
+ break;
+ }
+ }
+ if ("OC".equals(serviceFormatA) && Long.valueOf(100L).equals(serviceRate)) {
+ serviceType = StringConstants.SERVICE_TYPE_100GE_T;
+ }
+ if ("OTU".equals(serviceFormatA)) {
+ switch (serviceRate.intValue()) {
+ case 100:
+ serviceType = StringConstants.SERVICE_TYPE_OTU4;
+ break;
+ case 400:
+ serviceType = StringConstants.SERVICE_TYPE_OTUC4;
+ break;
+ default:
+ LOG.warn("Invalid service-rate {}", serviceRate);
+ break;
+ }
+ }
+ if ("ODU".equals(serviceFormatA)) {
+ switch (serviceRate.intValue()) {
+ case 100:
+ serviceType = StringConstants.SERVICE_TYPE_ODU4;
+ break;
+ case 400:
+ serviceType = StringConstants.SERVICE_TYPE_ODUC4;
+ break;
+ default:
+ LOG.warn("Invalid service-rate {}", serviceRate);
+ break;
+ }
+ }
+ }
+
private boolean readMdSal() {
InstanceIdentifier<Network> nwInstanceIdentifier = null;
- Network nw = null;
- if (("OC".equals(serviceFormatA)) || ("OTU".equals(serviceFormatA))
- || ("Ethernet".equals(serviceFormatA) && ((serviceRate == 100L) || (serviceRate == 400L)))) {
- LOG.info("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID);
- nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
- .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
- } else if ("ODU".equals(serviceFormatA)
- || ("Ethernet".equals(serviceFormatA) && ((serviceRate == 10L) || (serviceRate == 1L)))) {
- LOG.info("readMdSal: network {}", NetworkUtils.OTN_NETWORK_ID);
- nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
- .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID))).build();
+ switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_100GE_T:
+ case StringConstants.SERVICE_TYPE_400GE:
+ case StringConstants.SERVICE_TYPE_OTU4:
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ LOG.info("readMdSal: network {}", NetworkUtils.OVERLAY_NETWORK_ID);
+ nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
+ .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID))).build();
+ break;
+ case StringConstants.SERVICE_TYPE_100GE_M:
+ case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_1GE:
+ LOG.info("readMdSal: network {}", NetworkUtils.OTN_NETWORK_ID);
+ nwInstanceIdentifier = InstanceIdentifier.builder(Networks.class)
+ .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID))).build();
+ break;
+ default:
+ LOG.warn("readMdSal: unknown service-type for service-rate {} and service-format {}", serviceRate,
+ serviceFormatA);
+ break;
+ }
+
+ if (readTopology(nwInstanceIdentifier) != null) {
+ allNodes = readTopology(nwInstanceIdentifier).nonnullNode().values().stream().sorted((n1, n2)
+ -> n1.getNodeId().getValue().compareTo(n2.getNodeId().getValue())).collect(Collectors.toList());
+ Network1 nw1 = readTopology(nwInstanceIdentifier).augmentation(Network1.class);
+ if (nw1 != null) {
+ allLinks = nw1.nonnullLink().values().stream().sorted((l1, l2)
+ -> l1.getSource().getSourceTp().toString().compareTo(l2.getSource().getSourceTp().toString()))
+ .collect(Collectors.toList());
+ } else {
+ LOG.warn("no otn links in otn-topology");
+ }
+ if (allNodes == null || allNodes.isEmpty()) {
+ LOG.error("readMdSal: no nodes ");
+ return false;
+ }
+ LOG.info("readMdSal: network nodes: {} nodes added", allNodes.size());
+ LOG.debug("readMdSal: network nodes: {} nodes added", allNodes);
+
+ if (allLinks == null || allLinks.isEmpty()) {
+ LOG.error("readMdSal: no links ");
+ return false;
+ }
+ LOG.info("readMdSal: network links: {} links added", allLinks.size());
+ LOG.debug("readMdSal: network links: {} links added", allLinks);
+
+ return true;
} else {
- LOG.info("readMdSal: service-rate {} / service-format not handled {}", serviceRate, serviceFormatA);
+ LOG.error("readMdSal: network is null: {}", nwInstanceIdentifier);
return false;
}
+ }
+ private Network readTopology(InstanceIdentifier<Network> nwInstanceIdentifier) {
+ Network nw = null;
try {
Optional<Network> nwOptional =
networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, nwInstanceIdentifier).get();
if (nwOptional.isPresent()) {
nw = nwOptional.get();
LOG.debug("readMdSal: network nodes: nwOptional.isPresent = true {}", nw);
+ networkTransactionService.close();
}
} catch (InterruptedException | ExecutionException e) {
LOG.error("readMdSal: Error reading topology {}", nwInstanceIdentifier);
throw new RuntimeException(
"readMdSal: Error reading from operational store, topology : " + nwInstanceIdentifier + " :" + e);
}
- networkTransactionService.close();
-
- if (nw == null) {
- LOG.error("readMdSal: network is null: {}", nwInstanceIdentifier);
- return false;
- }
- allNodes = nw.nonnullNode().values().stream().sorted((n1, n2)
- -> n1.getNodeId().getValue().compareTo(n2.getNodeId().getValue())).collect(Collectors.toList());
- Network1 nw1 = nw.augmentation(Network1.class);
- if (nw1 != null) {
- allLinks = nw1.nonnullLink().values().stream().sorted((l1, l2)
- -> l1.getSource().getSourceTp().toString().compareTo(l2.getSource().getSourceTp().toString()))
- .collect(Collectors.toList());
- } else {
- LOG.warn("no otn links in otn-topology");
- }
- if (allNodes == null || allNodes.isEmpty()) {
- LOG.error("readMdSal: no nodes ");
- return false;
- }
- LOG.info("readMdSal: network nodes: {} nodes added", allNodes.size());
- LOG.debug("readMdSal: network nodes: {} nodes added", allNodes);
-
- if (allLinks == null || allLinks.isEmpty()) {
- LOG.error("readMdSal: no links ");
- return false;
- }
- LOG.info("readMdSal: network links: {} links added", allLinks.size());
- LOG.debug("readMdSal: network links: {} links added", allLinks);
-
- return true;
+ return nw;
}
private boolean analyzeNw() {
LOG.debug("analyzeNw: allNodes size {}, allLinks size {}", allNodes.size(), allLinks.size());
- if (StringConstants.SERVICE_TYPE_100GE.equals(serviceType)
+ if (StringConstants.SERVICE_TYPE_100GE_T.equals(serviceType)
|| StringConstants.SERVICE_TYPE_OTU4.equals(serviceType)
- || StringConstants.SERVICE_TYPE_400GE.equals(serviceType)) {
+ || StringConstants.SERVICE_TYPE_400GE.equals(serviceType)
+ || StringConstants.SERVICE_TYPE_OTUC4.equals(serviceType)) {
// 100GE service and OTU4 service are handled at the openroadm-topology layer
for (Node node : allNodes) {
validateNode(node);
return false;
}
- if (StringConstants.SERVICE_TYPE_100GE.equals(serviceType)
- || StringConstants.SERVICE_TYPE_OTU4.equals(serviceType)
- || StringConstants.SERVICE_TYPE_400GE.equals(serviceType)) {
- // 100GE or 400GE or OTU4 services are handled at WDM Layer
- PceLink pcelink = new PceLink(link, source, dest);
- if (!pcelink.isValid()) {
- dropOppositeLink(link);
- LOG.error(" validateLink: Link is ignored due errors in network data or in opposite link");
- return false;
- }
- LinkId linkId = pcelink.getLinkId();
- if (validateLinkConstraints(pcelink).equals(ConstraintTypes.HARD_EXCLUDE)) {
- dropOppositeLink(link);
- LOG.debug("validateLink: constraints : link is ignored == {}", linkId.getValue());
- return false;
- }
- switch (pcelink.getlinkType()) {
- case ROADMTOROADM:
- case EXPRESSLINK:
- allPceLinks.put(linkId, pcelink);
- source.addOutgoingLink(pcelink);
- LOG.debug("validateLink: {}-LINK added to allPceLinks {}",
- pcelink.getlinkType(), pcelink);
- break;
- case ADDLINK:
- pcelink.setClient(source.getRdmSrgClient(pcelink.getSourceTP().toString()));
- addLinks.add(pcelink);
- LOG.debug("validateLink: ADD-LINK saved {}", pcelink);
- break;
- case DROPLINK:
- pcelink.setClient(dest.getRdmSrgClient(pcelink.getDestTP().toString()));
- dropLinks.add(pcelink);
- LOG.debug("validateLink: DROP-LINK saved {}", pcelink);
- break;
- case XPONDERINPUT:
- // store separately all SRG links directly
- azSrgs.add(sourceId);
- // connected to A/Z
- if (!dest.checkTP(pcelink.getDestTP().toString())) {
- LOG.debug(
- "validateLink: XPONDER-INPUT is rejected as NW port is busy - {} ", pcelink);
- return false;
- }
- if (dest.getXpdrClient(pcelink.getDestTP().toString()) != null) {
- pcelink.setClient(dest.getXpdrClient(pcelink.getDestTP().toString()));
- }
- allPceLinks.put(linkId, pcelink);
- source.addOutgoingLink(pcelink);
- LOG.debug("validateLink: XPONDER-INPUT link added to allPceLinks {}", pcelink);
- break;
- // does it mean XPONDER==>>SRG ?
- case XPONDEROUTPUT:
- // store separately all SRG links directly
- azSrgs.add(destId);
- // connected to A/Z
- if (!source.checkTP(pcelink.getSourceTP().toString())) {
- LOG.debug(
- "validateLink: XPONDER-OUTPUT is rejected as NW port is busy - {} ", pcelink);
- return false;
- }
- if (source.getXpdrClient(pcelink.getSourceTP().toString()) != null) {
- pcelink.setClient(source.getXpdrClient(pcelink.getSourceTP().toString()));
- }
- allPceLinks.put(linkId, pcelink);
- source.addOutgoingLink(pcelink);
- LOG.debug("validateLink: XPONDER-OUTPUT link added to allPceLinks {}", pcelink);
- break;
- default:
- LOG.warn("validateLink: link type is not supported {}", pcelink);
- }
- return true;
-
- } else if ((StringConstants.SERVICE_TYPE_ODU4.equals(serviceType))
- || (StringConstants.SERVICE_TYPE_10GE.equals(serviceType))
- || (StringConstants.SERVICE_TYPE_1GE.equals(serviceType))) {
- // ODU4, 1GE and 10GE services relying on ODU2, ODU2e or ODU0 services are handled at OTN layer
- PceLink pceOtnLink = new PceLink(link, source, dest);
-
- if (!pceOtnLink.isOtnValid(link, serviceType)) {
- dropOppositeLink(link);
- LOG.error(" validateLink: Link is ignored due errors in network data or in opposite link");
- return false;
- }
-
- LinkId linkId = pceOtnLink.getLinkId();
- if (validateLinkConstraints(pceOtnLink).equals(ConstraintTypes.HARD_EXCLUDE)) {
- dropOppositeLink(link);
- LOG.debug("validateLink: constraints : link is ignored == {}", linkId.getValue());
+ switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_100GE_T:
+ case StringConstants.SERVICE_TYPE_OTU4:
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ case StringConstants.SERVICE_TYPE_400GE:
+ return processPceLink(link, sourceId, destId, source, dest);
+ case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_100GE_M:
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ case StringConstants.SERVICE_TYPE_1GE:
+ return processPceOtnLink(link, source, dest);
+ default:
+ LOG.error(" validateLink: Unmanaged service type {}", serviceType);
return false;
- }
-
- switch (pceOtnLink.getlinkType()) {
- case OTNLINK:
- if (dest.getXpdrClient(pceOtnLink.getDestTP().toString()) != null) {
- pceOtnLink.setClient(dest.getXpdrClient(pceOtnLink.getDestTP().toString()));
- }
-
- allPceLinks.put(linkId, pceOtnLink);
- source.addOutgoingLink(pceOtnLink);
- LOG.info("validateLink: OTN-LINK added to allPceLinks {}", pceOtnLink);
- break;
- default:
- LOG.warn("validateLink: link type is not supported {}", pceOtnLink);
- }
- return true;
-
- } else {
- LOG.error(" validateLink: Unmanaged service type {}", serviceType);
- return false;
}
-
}
private void validateNode(Node node) {
LOG.info("Device node id {} for {}", deviceNodeId, node);
PceOpticalNode pceNode = new PceOpticalNode(deviceNodeId, this.serviceType, portMapping, node, nodeType,
- mappingUtils.getOpenRoadmVersion(deviceNodeId), getSlotWidthGranularity(deviceNodeId, node.getNodeId()));
+ mappingUtils.getOpenRoadmVersion(deviceNodeId), getSlotWidthGranularity(deviceNodeId, node.getNodeId()),
+ getCentralFreqGranularity(deviceNodeId, node.getNodeId()));
pceNode.validateAZxponder(anodeId, znodeId, input.getServiceAEnd().getServiceFormat());
pceNode.initFrequenciesBitSet();
return true;
}
+ private boolean processPceLink(Link link, NodeId sourceId, NodeId destId, PceNode source, PceNode dest) {
+ PceLink pcelink = new PceLink(link, source, dest);
+ if (!pcelink.isValid()) {
+ dropOppositeLink(link);
+ LOG.error(" validateLink: Link is ignored due errors in network data or in opposite link");
+ return false;
+ }
+ LinkId linkId = pcelink.getLinkId();
+ if (validateLinkConstraints(pcelink).equals(ConstraintTypes.HARD_EXCLUDE)) {
+ dropOppositeLink(link);
+ LOG.debug("validateLink: constraints : link is ignored == {}", linkId.getValue());
+ return false;
+ }
+ switch (pcelink.getlinkType()) {
+ case ROADMTOROADM:
+ case EXPRESSLINK:
+ allPceLinks.put(linkId, pcelink);
+ source.addOutgoingLink(pcelink);
+ LOG.debug("validateLink: {}-LINK added to allPceLinks {}",
+ pcelink.getlinkType(), pcelink);
+ break;
+ case ADDLINK:
+ pcelink.setClient(source.getRdmSrgClient(pcelink.getSourceTP().toString()));
+ addLinks.add(pcelink);
+ LOG.debug("validateLink: ADD-LINK saved {}", pcelink);
+ break;
+ case DROPLINK:
+ pcelink.setClient(dest.getRdmSrgClient(pcelink.getDestTP().toString()));
+ dropLinks.add(pcelink);
+ LOG.debug("validateLink: DROP-LINK saved {}", pcelink);
+ break;
+ case XPONDERINPUT:
+ // store separately all SRG links directly
+ azSrgs.add(sourceId);
+ // connected to A/Z
+ if (!dest.checkTP(pcelink.getDestTP().toString())) {
+ LOG.debug(
+ "validateLink: XPONDER-INPUT is rejected as NW port is busy - {} ", pcelink);
+ return false;
+ }
+ if (dest.getXpdrClient(pcelink.getDestTP().toString()) != null) {
+ pcelink.setClient(dest.getXpdrClient(pcelink.getDestTP().toString()));
+ }
+ allPceLinks.put(linkId, pcelink);
+ source.addOutgoingLink(pcelink);
+ LOG.debug("validateLink: XPONDER-INPUT link added to allPceLinks {}", pcelink);
+ break;
+ // does it mean XPONDER==>>SRG ?
+ case XPONDEROUTPUT:
+ // store separately all SRG links directly
+ azSrgs.add(destId);
+ // connected to A/Z
+ if (!source.checkTP(pcelink.getSourceTP().toString())) {
+ LOG.debug(
+ "validateLink: XPONDER-OUTPUT is rejected as NW port is busy - {} ", pcelink);
+ return false;
+ }
+ if (source.getXpdrClient(pcelink.getSourceTP().toString()) != null) {
+ pcelink.setClient(source.getXpdrClient(pcelink.getSourceTP().toString()));
+ }
+ allPceLinks.put(linkId, pcelink);
+ source.addOutgoingLink(pcelink);
+ LOG.debug("validateLink: XPONDER-OUTPUT link added to allPceLinks {}", pcelink);
+ break;
+ default:
+ LOG.warn("validateLink: link type is not supported {}", pcelink);
+ }
+ return true;
+ }
+
+ private boolean processPceOtnLink(Link link, PceNode source, PceNode dest) {
+ PceLink pceOtnLink = new PceLink(link, source, dest);
+
+ if (!pceOtnLink.isOtnValid(link, serviceType)) {
+ dropOppositeLink(link);
+ LOG.error(" validateLink: Link is ignored due errors in network data or in opposite link");
+ return false;
+ }
+
+ LinkId linkId = pceOtnLink.getLinkId();
+ if (validateLinkConstraints(pceOtnLink).equals(ConstraintTypes.HARD_EXCLUDE)) {
+ dropOppositeLink(link);
+ LOG.debug("validateLink: constraints : link is ignored == {}", linkId.getValue());
+ return false;
+ }
+
+ switch (pceOtnLink.getlinkType()) {
+ case OTNLINK:
+ if (dest.getXpdrClient(pceOtnLink.getDestTP().toString()) != null) {
+ pceOtnLink.setClient(dest.getXpdrClient(pceOtnLink.getDestTP().toString()));
+ }
+
+ allPceLinks.put(linkId, pceOtnLink);
+ source.addOutgoingLink(pceOtnLink);
+ LOG.info("validateLink: OTN-LINK added to allPceLinks {}", pceOtnLink);
+ break;
+ default:
+ LOG.warn("validateLink: link type is not supported {}", pceOtnLink);
+ }
+ return true;
+ }
+
public PceNode getaendPceNode() {
return aendPceNode;
}
// deviceNodeId: openroadm-network level node
List<McCapabilities> mcCapabilities = mappingUtils.getMcCapabilitiesForNode(deviceNodeId);
String[] params = nodeId.getValue().split("-");
- // DEGX or SRGX
- String rdmModuleName = params[params.length - 1];
+ // DEGx or SRGx or XPDRx
+ String moduleName = params[params.length - 1];
for (McCapabilities mcCapabitility : mcCapabilities) {
- if (mcCapabitility.getMcNodeName().contains(rdmModuleName)
+ if (mcCapabitility.getMcNodeName().contains("XPDR")
+ && mcCapabitility.getSlotWidthGranularity() != null) {
+ return mcCapabitility.getSlotWidthGranularity().getValue();
+ }
+ if (mcCapabitility.getMcNodeName().contains(moduleName)
&& mcCapabitility.getSlotWidthGranularity() != null) {
return mcCapabitility.getSlotWidthGranularity().getValue();
}
}
return GridConstant.SLOT_WIDTH_50;
}
+
+ /**
+ * Get mc capability central-width granularity for device.
+ * @param deviceNodeId String
+ * @param nodeId NodeId
+ * @return center-freq granularity
+ */
+ private BigDecimal getCentralFreqGranularity(String deviceNodeId, NodeId nodeId) {
+ // nodeId: openroadm-topology level node
+ // deviceNodeId: openroadm-network level node
+ List<McCapabilities> mcCapabilities = mappingUtils.getMcCapabilitiesForNode(deviceNodeId);
+ String[] params = nodeId.getValue().split("-");
+ // DEGx or SRGx or XPDRx
+ String moduleName = params[params.length - 1];
+ for (McCapabilities mcCapabitility : mcCapabilities) {
+ if (mcCapabitility.getMcNodeName().contains("XPDR")
+ && mcCapabitility.getCenterFreqGranularity() != null) {
+ return mcCapabitility.getCenterFreqGranularity().getValue();
+ }
+ if (mcCapabitility.getMcNodeName().contains(moduleName)
+ && mcCapabitility.getCenterFreqGranularity() != null) {
+ return mcCapabitility.getCenterFreqGranularity().getValue();
+ }
+ }
+ return GridConstant.SLOT_WIDTH_50;
+ }
}
import org.opendaylight.yang.gen.v1.http.org.openroadm.link.rev200529.span.attributes.LinkConcatenationKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev200529.networks.network.link.oms.attributes.Span;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmLinkType;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.LinkId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.Link;
}
OtnLinkType otnLinkType = link
- .augmentation(org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.Link1.class)
+ .augmentation(org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.Link1.class)
.getOtnLinkType();
if (this.availableBandwidth == 0L) {
LOG.error("PceLink: No bandwidth available for OTN Link, link {} is ignored ", linkId);
long neededBW;
OtnLinkType neededType = null;
switch (serviceType) {
-
+ case "ODUC4":
+ if (this.usedBandwidth != 0L) {
+ return false;
+ }
+ neededBW = 400000L;
+ neededType = OtnLinkType.OTUC4;
+ break;
case "ODU4":
if (this.usedBandwidth != 0L) {
return false;
case "ODU1":
neededBW = 2500L;
break;
+ case "100GEm":
+ neededBW = 100000L;
+ neededType = OtnLinkType.ODUC4;
+ break;
case "10GE":
neededBW = 10000L;
neededType = OtnLinkType.ODTU4;
* @return BigDecimal.
*/
BigDecimal getSlotWidthGranularity();
+
+ /**
+ * For optical node the central-frequency granularity from mc capabilities.
+ * @return BigDecimal.
+ */
+ BigDecimal getCentralFreqGranularity();
}
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.available.freq.map.AvailFreqMapsKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCH;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOTUCnODUCn;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOtsiOtsigroup;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
private BitSet frequenciesBitSet;
private String version;
private BigDecimal slotWidthGranularity;
+ private BigDecimal centralFreqGranularity;
public PceOpticalNode(String deviceNodeId, String serviceType, PortMapping portMapping, Node node,
- OpenroadmNodeType nodeType, String version, BigDecimal slotWidthGranularity) {
+ OpenroadmNodeType nodeType, String version, BigDecimal slotWidthGranularity,
+ BigDecimal centralFreqGranularity) {
+
if (deviceNodeId != null
&& serviceType != null
&& portMapping != null
this.nodeType = nodeType;
this.version = version;
this.slotWidthGranularity = slotWidthGranularity;
+ this.centralFreqGranularity = centralFreqGranularity;
this.adminStates = node.augmentation(org.opendaylight.yang.gen.v1.http
.org.openroadm.common.network.rev200529.Node1.class).getAdministrativeState();
this.state = node.augmentation(org.opendaylight.yang.gen.v1.http
}
switch (this.serviceType) {
case "400GE":
- if (mapping.getSupportedInterfaceCapability().contains(IfOTUCnODUCn.class)) {
+ if (mapping.getSupportedInterfaceCapability().contains(IfOtsiOtsigroup.class)) {
return true;
} else {
return false;
}
// find Client of this network TP
String client;
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1 tpceTp1 =
- tp.augmentation(org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1 tpceTp1 =
+ tp.augmentation(org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511
.TerminationPoint1.class);
if (tpceTp1 != null) {
client = tpceTp1.getAssociatedConnectionMapPort();
return slotWidthGranularity;
}
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getCentralFreqGranularity()
+ */
+ @Override
+ public BigDecimal getCentralFreqGranularity() {
+ return centralFreqGranularity;
+ }
+
}
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.OpenroadmTpType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODTU4TsAllocated;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODTUCnTs;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.networks.network.node.SwitchingPools;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If10GEODU2e;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.If1GEODU0;
import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOCHOTU4ODU4;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev200327.IfOtsiOtsigroup;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.network.Node;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
= tp.augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev200529
.TerminationPoint1.class);
//TODO many nested if-structures below, this needs to be reworked
- if (OpenroadmTpType.XPONDERNETWORK.equals(ocnTp1.getTpType())
- && StringConstants.SERVICE_TYPE_ODU4.equals(this.otnServiceType)) {
+ if (OpenroadmTpType.XPONDERNETWORK.equals(ocnTp1.getTpType())) {
TerminationPoint1 ontTp1;
if (tp.augmentation(TerminationPoint1.class) != null) {
ontTp1 = tp.augmentation(TerminationPoint1.class);
} else {
continue;
}
- if (checkTpForOdtuTermination(ontTp1)) {
- LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
- this.availableXpdrNWTps.add(tp.getTpId());
- } else {
- LOG.error("TP {} of {} does not allow ODU4 termination creation", tp.getTpId().getValue(),
- node.getNodeId().getValue());
- }
- } else if (OpenroadmTpType.XPONDERNETWORK.equals(ocnTp1.getTpType())
- && (this.otnServiceType.equals(StringConstants.SERVICE_TYPE_10GE)
- || StringConstants.SERVICE_TYPE_1GE.equals(this.otnServiceType))) {
- TerminationPoint1 ontTp1;
- if (tp.augmentation(TerminationPoint1.class) != null) {
- ontTp1 = tp.augmentation(TerminationPoint1.class);
- } else {
- continue;
- }
- if (StringConstants.SERVICE_TYPE_10GE.equals(otnServiceType)
- && checkOdtuTTPforLoOduCreation(ontTp1, 10)
- || StringConstants.SERVICE_TYPE_1GE.equals(otnServiceType)
- && checkOdtuTTPforLoOduCreation(ontTp1, 1)) {
- LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
- this.availableXpdrNWTps.add(tp.getTpId());
- } else {
- if (StringConstants.SERVICE_TYPE_10GE.equals(otnServiceType)) {
- LOG.error("TP {} of {} does not allow OD2e termination creation", tp.getTpId().getValue(),
- node.getNodeId().getValue());
- } else if (StringConstants.SERVICE_TYPE_1GE.equals(otnServiceType)) {
- LOG.error("TP {} of {} does not allow ODU0 termination creation", tp.getTpId().getValue(),
- node.getNodeId().getValue());
- } else {
- LOG.error("TP {} of {} does not allow any termination creation", tp.getTpId().getValue(),
- node.getNodeId().getValue());
- }
+ switch (this.otnServiceType) {
+ case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ if (!checkTpForOdtuTermination(ontTp1)) {
+ LOG.error("TP {} of {} does not allow ODU4 termination creation",
+ tp.getTpId().getValue(), node.getNodeId().getValue());
+ continue;
+ }
+ break;
+
+ case StringConstants.SERVICE_TYPE_10GE:
+ if (!checkOdtuTTPforLoOduCreation(ontTp1, 10)) {
+ LOG.error("TP {} of {} does not allow OD2e termination creation",
+ tp.getTpId().getValue(), node.getNodeId().getValue());
+ continue;
+ }
+ break;
+ case StringConstants.SERVICE_TYPE_100GE_M:
+ if (!checkOdtuTTPforLoOduCreation(ontTp1, 20)) {
+ LOG.error("TP {} of {} does not allow ODU4 termination creation",
+ tp.getTpId().getValue(), node.getNodeId().getValue());
+ continue;
+ }
+ break;
+ case StringConstants.SERVICE_TYPE_1GE:
+ if (!checkOdtuTTPforLoOduCreation(ontTp1, 1)) {
+ LOG.error("TP {} of {} does not allow ODU0 termination creation",
+ tp.getTpId().getValue(), node.getNodeId().getValue());
+ continue;
+ }
+ break;
+
+ default:
+ LOG.error("TP {} of {} does not allow any termination creation",
+ tp.getTpId().getValue(), node.getNodeId().getValue());
+ continue;
}
+ LOG.info("TP {} of XPONDER {} is validated", tp.getTpId(), node.getNodeId().getValue());
+ this.availableXpdrNWTps.add(tp.getTpId());
} else if (OpenroadmTpType.XPONDERCLIENT.equals(ocnTp1.getTpType())
&& (StringConstants.SERVICE_TYPE_10GE.equals(this.otnServiceType)
- || StringConstants.SERVICE_TYPE_1GE.equals(this.otnServiceType))) {
+ || StringConstants.SERVICE_TYPE_100GE_M.equals(this.otnServiceType)
+ || StringConstants.SERVICE_TYPE_1GE.equals(this.otnServiceType))) {
TerminationPoint1 ontTp1;
if (tp.augmentation(TerminationPoint1.class) != null) {
ontTp1 = tp.augmentation(TerminationPoint1.class);
}
}
- if ((StringConstants.SERVICE_TYPE_ODU4.equals(this.otnServiceType) && mode.equals("AZ"))
+ if (((StringConstants.SERVICE_TYPE_ODU4.equals(this.otnServiceType)
+ || StringConstants.SERVICE_TYPE_ODUC4.equals(this.otnServiceType)) && mode.equals("AZ"))
|| ((StringConstants.SERVICE_TYPE_10GE.equals(this.otnServiceType)
+ || StringConstants.SERVICE_TYPE_100GE_M.equals(this.otnServiceType)
|| StringConstants.SERVICE_TYPE_1GE.equals(this.otnServiceType))
&& ((mode.equals("AZ") && checkSwPool(availableXpdrClientTps, availableXpdrNWTps, 1, 1))
|| (mode.equals("intermediate") && checkSwPool(null, availableXpdrNWTps, 0, 2)))
private boolean checkTpForOdtuTermination(TerminationPoint1 ontTp1) {
for (SupportedInterfaceCapability sic : ontTp1.getTpSupportedInterfaces().getSupportedInterfaceCapability()
.values()) {
- LOG.debug("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
- if (sic.getIfCapType().equals(IfOCHOTU4ODU4.class)
- && ontTp1.getXpdrTpPortConnectionAttributes().getTsPool() == null) {
+ LOG.info("in checkTpForOduTermination - sic = {}", sic.getIfCapType());
+ if ((sic.getIfCapType().equals(IfOCHOTU4ODU4.class) || sic.getIfCapType().equals(IfOtsiOtsigroup.class))
+ && (ontTp1.getXpdrTpPortConnectionAttributes() == null
+ || ontTp1.getXpdrTpPortConnectionAttributes().getTsPool() == null)) {
return true;
}
}
if (ontTp1.getXpdrTpPortConnectionAttributes() != null
&& ontTp1.getXpdrTpPortConnectionAttributes().getTsPool() != null
&& ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool() != null
- && ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool().values()
+ && (ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool().values()
.stream().findFirst().get().getOdtuType()
.equals(ODTU4TsAllocated.class)
+ ||
+ ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool().values()
+ .stream().findFirst().get().getOdtuType()
+ .equals(ODTUCnTs.class))
&& !ontTp1.getXpdrTpPortConnectionAttributes().getOdtuTpnPool().values()
.stream().findFirst().get().getTpnPool().isEmpty()
&& (ontTp1.getXpdrTpPortConnectionAttributes().getTsPool().size() >= tsNb)) {
return true;
}
break;
- case StringConstants.SERVICE_TYPE_100GE:
+ case StringConstants.SERVICE_TYPE_100GE_T:
+ case StringConstants.SERVICE_TYPE_100GE_M:
if (sic.getIfCapType().equals(If100GEODU4.class)) {
return true;
}
.collect(Collectors.toList());
for (TerminationPoint tp : networkTpList) {
- if (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool() != null
- && tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool()
- .values().stream().findFirst().get().getOdtuType().equals(ODTU4TsAllocated.class)) {
+ if (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes() != null
+ && tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool() != null
+ && (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool()
+ .values().stream().findFirst().get().getOdtuType().equals(ODTU4TsAllocated.class)
+ || tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getOdtuTpnPool()
+ .values().stream().findFirst().get().getOdtuType().equals(ODTUCnTs.class))) {
@Nullable
List<Uint16> tpnPool = tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes()
.getOdtuTpnPool().values().stream().findFirst().get().getTpnPool();
.collect(Collectors.toList());
for (TerminationPoint tp : networkTpList) {
- if (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getTsPool() != null) {
+ if (tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes() != null
+ && tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes().getTsPool() != null) {
@Nullable
List<Uint16> tsPool = tp.augmentation(TerminationPoint1.class).getXpdrTpPortConnectionAttributes()
.getTsPool();
public BigDecimal getSlotWidthGranularity() {
return null;
}
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see org.opendaylight.transportpce.pce.networkanalyzer.PceNode#getCentralFreqGranularity()
+ */
+ @Override
+ public BigDecimal getCentralFreqGranularity() {
+ return null;
+ }
}
NodeBuilder node1Builder = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes());
node = node1Builder.setNodeId(new NodeId("test")).build();
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50,
+ GridConstant.SLOT_WIDTH_50);
PceOpticalNode pceOpticalNode2 = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50,
+ GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
pceLink.setClient("XPONDER-CLIENT");
pceResult = new PceResult();
pceResult.setRC("200");
pceResult.setRate(Long.valueOf(1));
- pceResult.setServiceType(StringConstants.SERVICE_TYPE_100GE);
+ pceResult.setServiceType(StringConstants.SERVICE_TYPE_100GE_T);
Map<LinkId, PceLink> map = Map.of(new LinkId("OpenROADM-3-1-DEG1-to-OpenROADM-3-2-DEG1"), pceLink);
pcePathDescription = new PcePathDescription(List.of(pceLink),
map, pceResult);
package org.opendaylight.transportpce.pce;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.transportpce.pce.utils.PceTestData;
import org.opendaylight.transportpce.pce.utils.PceTestUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.MappingBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.nodes.NodeInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.nodes.NodeInfoBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
import org.opendaylight.yangtools.yang.model.parser.api.YangParserFactory;
@RunWith(MockitoJUnitRunner.class)
private PceSendingPceRPCs pceSendingPceRPCs;
private NetworkTransactionImpl networkTransaction;
+ private Mapping mapping;
@Mock
private YangParserFactory yangParserFactory;
@Mock
"mylogin", "mypassword", getDataStoreContextUtil().getBindingDOMCodecServices());
pceSendingPceRPCs = new PceSendingPceRPCs(PceTestData.getPCE_test1_request_54(),
networkTransaction, gnpyConsumer, portMapping);
+ mapping = new MappingBuilder().setLogicalConnectionPoint("logicalConnectionPoint").setPortQual("xpdr-client")
+ .build();
+ NodeInfo info = new NodeInfoBuilder().setNodeType(NodeTypes.Xpdr).build();
+ Nodes node = new NodesBuilder().withKey(new NodesKey("node")).setNodeId("node").setNodeInfo(info).build();
+ when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
+ when(portMapping.getNode(anyString())).thenReturn(node);
}
@Test
pceSendingPceRPCs =
new PceSendingPceRPCs(PceTestData.getGnpyPCERequest("XPONDER-1", "XPONDER-2"),
networkTransaction, gnpyConsumer, portMapping);
-
+ when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
pceSendingPceRPCs.pathComputation();
Assert.assertTrue(gnpyConsumer.isAvailable());
jerseyServer.tearDown();
@Test
public void getIncludePceNodesTest() {
Assert.assertTrue(pceConstraints.getIncludePceNodes().size() == 0);
- pceConstraints.setIncludePceNode(new PceOpticalNode(null, null, null, null, null, null, null));
+ pceConstraints.setIncludePceNode(new PceOpticalNode(null, null, null, null, null, null, null, null));
Assert.assertTrue(pceConstraints.getIncludePceNodes().size() == 1);
}
node = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes()).build();
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
PceOpticalNode pceOpticalNode2 = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
pceLink.setClient("XPONDER-CLIENT");
.setNodeId(nodeId).withKey(new NodeKey(nodeId))
.build();
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
NodeId nodeId2 = new NodeId("OpenROADM-3-1-DEG1");
Node node2 = NodeUtils.getNodeBuilder(NodeUtils.geSupportingNodes())
.setNodeId(nodeId2).withKey(new NodeKey(nodeId2)).build();
pceOpticalNode2 = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node2,
- OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode2);
pceLink.setClient("XPONDER-CLIENT");
pceGraph = new PceGraph(pceOpticalNode, pceOpticalNode2, allPceNodes,
pceHardConstraints,
null, rc,
- StringConstants.SERVICE_TYPE_100GE);
+ StringConstants.SERVICE_TYPE_100GE_T);
Assert.assertEquals(pceGraph.calcPath(), false);
}
*/
package org.opendaylight.transportpce.pce.networkanalyzer;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.when;
+
import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnitRunner;
import org.opendaylight.transportpce.common.StringConstants;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
import org.opendaylight.transportpce.common.network.RequestProcessor;
import org.opendaylight.transportpce.pce.constraints.PceConstraintsCalc;
import org.opendaylight.transportpce.pce.utils.TransactionUtils;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev200128.PathComputationRequestInput;
-
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.MappingBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.NodesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.nodes.NodeInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.network.nodes.NodeInfoBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
+//import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
+
+@RunWith(MockitoJUnitRunner.StrictStubs.class)
public class PceCalculationTest extends AbstractTest {
private PceCalculation pceCalculation;
private PceConstraintsCalc pceConstraintsCalc;
private PceResult pceResult = new PceResult();
+ private Mapping mapping;
+
+ @Mock
+ private PortMapping portMapping;
// setup object
@Before
pceResult.setRC("200");
PceTestUtils.writeNetworkIntoDataStore(this.getDataBroker(), this.getDataStoreContextUtil(),
TransactionUtils.getNetworkForSpanLoss());
-
pceConstraintsCalc = new PceConstraintsCalc(PceTestData.getPCERequest(),
new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())));
-
- pceCalculation = new PceCalculation(
- PceTestData.getPCERequest(),
- new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())),
- pceConstraintsCalc.getPceHardConstraints(),
- pceConstraintsCalc.getPceSoftConstraints(),
- pceResult,
- null);
+ mapping = new MappingBuilder().setLogicalConnectionPoint("logicalConnectionPoint").setPortQual("xpdr-client")
+ .build();
+ NodeInfo info = new NodeInfoBuilder().setNodeType(NodeTypes.Xpdr).build();
+ Nodes node = new NodesBuilder().withKey(new NodesKey("node")).setNodeId("node").setNodeInfo(info).build();
+ when(portMapping.getMapping(anyString(), anyString())).thenReturn(mapping);
+ when(portMapping.getNode(anyString())).thenReturn(node);
}
@Test
public void testPceCalculationValues() {
-
+ pceCalculation = new PceCalculation(
+ PceTestData.getPCERequest(),
+ new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())),
+ pceConstraintsCalc.getPceHardConstraints(),
+ pceConstraintsCalc.getPceSoftConstraints(),
+ pceResult,
+ portMapping);
pceCalculation.retrievePceNetwork();
- Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE, pceCalculation.getServiceType());
+ Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
Assert.assertNotNull(pceCalculation.getReturnStructure());
Assert.assertNull(pceCalculation.getaendPceNode());
@Test
public void testPceCalculationValues2() {
-
pceCalculation = new PceCalculation(
PceTestData.getPathComputationRequestInputWithCoRoutingOrGeneral(),
new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())),
pceConstraintsCalc.getPceHardConstraints(),
pceConstraintsCalc.getPceSoftConstraints(),
- pceResult, null);
+ pceResult, portMapping);
pceCalculation.retrievePceNetwork();
- Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE, pceCalculation.getServiceType());
+ Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
Assert.assertNotNull(pceCalculation.getReturnStructure());
Assert.assertNull(pceCalculation.getaendPceNode());
@Test
public void testPceCalculationValues42() {
-
PathComputationRequestInput input = PceTestData.getPathComputationRequestInputWithCoRoutingOrGeneral2();
pceConstraintsCalc = new PceConstraintsCalc(input,
new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())));
-
pceCalculation = new PceCalculation(
PceTestData.getPCE_test3_request_54(),
new NetworkTransactionImpl(new RequestProcessor(this.getDataBroker())),
pceConstraintsCalc.getPceHardConstraints(),
pceConstraintsCalc.getPceSoftConstraints(),
- pceResult, null);
-
+ pceResult, portMapping);
pceCalculation.retrievePceNetwork();
-// Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE, pceCalculation.getServiceType());
+ Assert.assertEquals(StringConstants.SERVICE_TYPE_100GE_T, pceCalculation.getServiceType());
Assert.assertNotNull(pceCalculation.getReturnStructure());
Assert.assertNull(pceCalculation.getaendPceNode());
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
}
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
}
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
}
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
}
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes());
Node node = node1Builder.setNodeId(new NodeId("test")).build();
PceOpticalNode pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceLink = new PceLink(link, pceOpticalNode, pceOpticalNode);
Assert.assertNotNull(MapUtils.getOmsAttributesSpan(link));
Assert.assertNotNull(pceLink.calcSpanOSNR());
public void isValidTest() {
OpenroadmNodeType nodeType = OpenroadmNodeType.ROADM;
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node, nodeType,
- StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
Assert.assertTrue(pceOpticalNode.isValid());
}
public void testInitSrgTps() {
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
pceOpticalNode.initFrequenciesBitSet();
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.XPONDERNETWORK);
Node specificNode = node1Builder.build();
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, specificNode,
- OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.SRG, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
Assert.assertTrue(pceOpticalNode.isValid());
Assert.assertEquals(availableBitSet, pceOpticalNode.getBitSetData().get(88,96));
@Test
public void testInitXndrTpDegTypes() {
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
Assert.assertTrue(pceOpticalNode.isValid());
Assert.assertEquals(usedBitSet,pceOpticalNode.getBitSetData().get(88,96));
@Test
public void testInitXndrTpXpondrTypes() {
pceOpticalNode = new PceOpticalNode(deviceNodeId, serviceType, portMapping, node,
- OpenroadmNodeType.XPONDER, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.XPONDER, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initFrequenciesBitSet();
Assert.assertTrue(pceOpticalNode.isValid());
Assert.assertEquals(availableBitSet, pceOpticalNode.getBitSetData().get(88,96));
@Test
public void testinitFrequenciesBitSet() {
pceOpticalNode = new PceOpticalNode(null, null, null, node,
- OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
pceOpticalNode.initFrequenciesBitSet();
Assert.assertFalse(pceOpticalNode.isValid());
@Test
public void testGetRdmSrgClient() {
pceOpticalNode = new PceOpticalNode(null, null, null, node,
- OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertNull(pceOpticalNode.getRdmSrgClient("7"));
Assert.assertFalse(pceOpticalNode.isValid());
NodeBuilder node1Builder = getNodeBuilderEmpty(geSupportingNodes(), OpenroadmTpType.SRGTXRXPP);
Node specificNode = node1Builder.setNodeId(new NodeId("test")).build();
pceOpticalNode = new PceOpticalNode(null, null, null, specificNode,
- OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
pceOpticalNode.initFrequenciesBitSet();
pceOpticalNode.initXndrTps(ServiceFormat.OMS);
@Test
public void testGetRdmSrgClientDeg() {
pceOpticalNode = new PceOpticalNode(null, null, null, node,
- OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.DEGREE, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertNull(pceOpticalNode.getRdmSrgClient("7"));
Assert.assertFalse(pceOpticalNode.isValid());
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.SRGTXCP);
Node specificNode = node1Builder.build();
pceOpticalNode = new PceOpticalNode(null, null, null, specificNode,
- OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertFalse(pceOpticalNode.isValid());
Assert.assertNull(pceOpticalNode.getBitSetData());
NodeBuilder node1Builder = getNodeBuilder(geSupportingNodes(), OpenroadmTpType.DEGREERXTTP);
node = node1Builder.build();
pceOpticalNode = new PceOpticalNode(null, null, null, node,
- OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1, GridConstant.SLOT_WIDTH_50);
+ OpenroadmNodeType.ROADM, StringConstants.OPENROADM_DEVICE_VERSION_2_2_1,
+ GridConstant.SLOT_WIDTH_50, GridConstant.SLOT_WIDTH_50);
pceOpticalNode.initSrgTps();
Assert.assertNull(pceOpticalNode.getRdmSrgClient("2"));
Assert.assertFalse(pceOpticalNode.isValid());
@Test
public void testIsPceOtnNodeValidNode() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.DEGREE,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE_M);
pceOtnNode.initXndrTps("AZ");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
@Test
public void testIsPceOtnNodeValidNodeTypeNull() {
pceOtnNode = new PceOtnNode(node, null,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE_M);
pceOtnNode.initXndrTps("AZ");
pceOtnNode.checkAvailableTribPort();
pceOtnNode.checkAvailableTribSlot();
@Test
public void testIsPceOtnNodeValidNodeTypeDeg() {
pceOtnNode = new PceOtnNode(node, OpenroadmNodeType.DEGREE,
- new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE);
+ new NodeId("optical"), ServiceFormat.OMS.getName(), StringConstants.SERVICE_TYPE_100GE_M);
pceOtnNode.initXndrTps("AZ");
Assert.assertFalse("not valid node , its type isn't one of MUXPDR or SWITCH or TPDR" ,
pceOtnNode.isPceOtnNodeValid(pceOtnNode));
ServiceHandlerHeader serviceHandlerHeader = new ServiceHandlerHeaderBuilder()
.setRequestId("request 1")
.build();
+
ServiceAEnd serviceAEnd = new ServiceAEndBuilder()
- .setServiceRate(Uint32.valueOf(0))
+ .setServiceRate(Uint32.valueOf(100))
+ .setServiceFormat(ServiceFormat.Ethernet)
.setNodeId("XPONDER-1-2")
.build();
ServiceZEnd serviceZEnd = new ServiceZEndBuilder()
.setServiceRate(Uint32.valueOf(0))
+ .setServiceFormat(ServiceFormat.Ethernet)
.setNodeId("XPONDER-3-2")
.build();
PathComputationRequestInput input = new PathComputationRequestInputBuilder()
.setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
// Maint test signal
MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
- .setTestPattern(TestPattern.PRBS23)
+ // PRBS value should be PRBS31 if enabled is true
+ .setTestPattern(TestPattern.PRBS31)
.setEnabled(false);
// Create an ODUC4 object
.setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
// Maint test signal
MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
- .setTestPattern(TestPattern.PRBS23)
+ // PRBS value should be PRBS31 if enabled is true
+ .setTestPattern(TestPattern.PRBS31)
.setEnabled(false);
// Create an ODUC4 object
return oduInterfaceBuilder.getName();
}
+ public String createOpenRoadmOtnOducnInterface(String nodeId, String logicalConnPoint,
+ String supportingOtucn)
+ throws OpenRoadmInterfaceException {
+ Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
+ if (portMap == null) {
+ throw new OpenRoadmInterfaceException(
+ String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
+ nodeId, logicalConnPoint));
+ }
+ // Create ODUcn object
+ // Start with OPU object
+ // OPU payload
+ OpuBuilder opuBuilder = new OpuBuilder()
+ .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
+ .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
+ // Maint test signal
+ MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
+ // PRBS value should be PRBS31 if enabled is true
+ .setTestPattern(TestPattern.PRBS31)
+ .setEnabled(false);
+
+ // Create an ODUC4 object
+ OduBuilder oduBuilder = new OduBuilder()
+ .setRate(ODUCn.class)
+ .setOducnNRate(Uint16.valueOf(4))
+ .setOduFunction(ODUTTP.class)
+ .setMonitoringMode(MonitoringMode.Terminated)
+ .setTimActEnabled(false)
+ .setTimDetectMode(TimDetectMode.Disabled)
+ .setDegmIntervals(Uint8.valueOf(2))
+ .setDegthrPercentage(Uint16.valueOf(100))
+ .setOpu(opuBuilder.build())
+ .setMaintTestsignal(maintTestsignal.build());
+
+ InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMap, OtnOdu.class,
+ logicalConnPoint + "-ODUC4");
+
+ // Create a list
+ List<String> listSupportingOtucnInterface = new ArrayList<>();
+ listSupportingOtucnInterface.add(supportingOtucn);
+
+ oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
+
+ oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
+
+ // Post interface on the device
+ openRoadmInterfaces.postInterface(nodeId, oduInterfaceBuilder);
+
+ // Post the equipment-state change on the device circuit-pack if xpdr node
+ if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
+ this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
+ }
+ // Update the port-mapping with the interface information
+ this.portMapping.updateMapping(nodeId, portMap);
+ return oduInterfaceBuilder.getName();
+ }
+
+
+ // With SAPI and DAPI information
+ public String createOpenRoadmOtnOducnInterface(String anodeId, String alogicalConnPoint,
+ String supportingOtucn, String znodeId, String zlogicalConnPoint)
+ throws OpenRoadmInterfaceException {
+ Mapping portMapA = portMapping.getMapping(anodeId, alogicalConnPoint);
+ Mapping portMapZ = portMapping.getMapping(znodeId, zlogicalConnPoint);
+ if (portMapA == null) {
+ throw new OpenRoadmInterfaceException(
+ String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
+ anodeId, alogicalConnPoint));
+ }
+ // On the Zside
+ if (portMapZ == null) {
+ throw new OpenRoadmInterfaceException(
+ String.format(MAPPING_ERROR_EXCEPTION_MESSAGE,
+ znodeId, zlogicalConnPoint));
+
+ }
+ // Create ODUcn object
+ // Start with OPU object
+ // OPU payload
+ OpuBuilder opuBuilder = new OpuBuilder()
+ .setExpPayloadType(PayloadTypeDef.getDefaultInstance("22"))
+ .setPayloadType(PayloadTypeDef.getDefaultInstance("22"));
+ // Maint test signal
+ MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
+ // PRBS value should be PRBS31 if enabled is true
+ .setTestPattern(TestPattern.PRBS31)
+ .setEnabled(false);
+
+ // Create an ODUC4 object
+ OduBuilder oduBuilder = new OduBuilder()
+ .setRate(ODUCn.class)
+ .setOducnNRate(Uint16.valueOf(4))
+ .setOduFunction(ODUTTP.class)
+ .setMonitoringMode(MonitoringMode.Terminated)
+ .setTimActEnabled(false)
+ .setTimDetectMode(TimDetectMode.Disabled)
+ .setDegmIntervals(Uint8.valueOf(2))
+ .setDegthrPercentage(Uint16.valueOf(100))
+ .setOpu(opuBuilder.build())
+ .setTxSapi(portMapA.getLcpHashVal())
+ .setTxDapi(portMapZ.getLcpHashVal())
+ .setExpectedSapi(portMapZ.getLcpHashVal())
+ .setExpectedDapi(portMapZ.getLcpHashVal())
+ .setMaintTestsignal(maintTestsignal.build());
+
+ InterfaceBuilder oduInterfaceBuilder = createGenericInterfaceBuilder(portMapA, OtnOdu.class,
+ alogicalConnPoint + "-ODUC4");
+
+ // Create a list
+ List<String> listSupportingOtucnInterface = new ArrayList<>();
+ listSupportingOtucnInterface.add(supportingOtucn);
+
+ oduInterfaceBuilder.setSupportingInterfaceList(listSupportingOtucnInterface);
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder oduIf1Builder =
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
+
+ oduInterfaceBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
+
+ // Post interface on the device
+ openRoadmInterfaces.postInterface(anodeId, oduInterfaceBuilder);
+
+ // Post the equipment-state change on the device circuit-pack if xpdr node
+ if (portMapA.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
+ this.openRoadmInterfaces.postEquipmentState(anodeId, portMapA.getSupportingCircuitPackName(), true);
+ }
+ // Update the port-mapping with the interface information
+ this.portMapping.updateMapping(anodeId, portMapA);
+ return oduInterfaceBuilder.getName();
+ }
+
// This is only for transponder
public String createOpenRoadmOduflexInterface(String nodeId, String logicalConnPoint,
String supportingOducn)
// Maint test signal
MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
- .setTestPattern(TestPattern.PRBS23)
+ // PRBS value should be PRBS31 if enabled is true
+ .setTestPattern(TestPattern.PRBS31)
.setEnabled(false);
// Parent Odu-allocation
// Maint test signal
MaintTestsignalBuilder maintTestsignal = new MaintTestsignalBuilder()
- .setTestPattern(TestPattern.PRBS23)
+ // PRBS value should be PRBS31 if enabled is true
+ .setTestPattern(TestPattern.PRBS31)
.setEnabled(false);
// Parent Odu-allocation
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class OpenRoadmInterfaceFactory {
private static final String OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG =
- "OTN funtions are not supported by Openroadm models 1.2.1";
+ "OTN functions are not supported by Openroadm models 1.2.1";
+ private static final String OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_2_2_1_MSG =
+ "OTN functions are not supported by Openroadm models 2.2.1";
private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterfaceFactory.class);
private final MappingUtils mappingUtils;
private final OpenRoadmInterface121 openRoadmInterface121;
private final OpenRoadmInterface221 openRoadmInterface221;
private final OpenRoadmInterface710 openRoadmInterface710;
- private final OpenRoadmOtnInterface221 openRoadmOtnInterface;
+ private final OpenRoadmOtnInterface221 openRoadmOtnInterface221;
+ private final OpenRoadmOtnInterface710 openRoadmOtnInterface710;
public OpenRoadmInterfaceFactory(MappingUtils mappingUtils, OpenRoadmInterface121 openRoadmInterface121,
OpenRoadmInterface221 openRoadmInterface221, OpenRoadmInterface710 openRoadmInterface710,
- OpenRoadmOtnInterface221 openRoadmOTNInterface) {
+ OpenRoadmOtnInterface221 openRoadmOTNInterface221, OpenRoadmOtnInterface710 openRoadmOtnInterface710) {
this.mappingUtils = mappingUtils;
this.openRoadmInterface121 = openRoadmInterface121;
this.openRoadmInterface221 = openRoadmInterface221;
this.openRoadmInterface710 = openRoadmInterface710;
- this.openRoadmOtnInterface = openRoadmOTNInterface;
+ this.openRoadmOtnInterface221 = openRoadmOTNInterface221;
+ this.openRoadmOtnInterface710 = openRoadmOtnInterface710;
}
public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
}
public boolean isUsedByXc(String nodeId, String interfaceName, String xc,
- DeviceTransactionManager deviceTransactionManager) {
+ DeviceTransactionManager deviceTransactionManager) {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
return openRoadmInterface121.isUsedByXc(nodeId, interfaceName, xc, deviceTransactionManager);
}
public String createOpenRoadmEth1GInterface(String nodeId,
- String logicalConnPoint) throws OpenRoadmInterfaceException {
+ String logicalConnPoint) throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmOtnInterface.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
+ return openRoadmOtnInterface221.createOpenRoadmEth1GInterface(nodeId, logicalConnPoint);
default:
return null;
}
}
public String createOpenRoadmEth10GInterface(String nodeId,
- String logicalConnPoint) throws OpenRoadmInterfaceException {
+ String logicalConnPoint) throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmOtnInterface.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint);
+ return openRoadmOtnInterface221.createOpenRoadmEth10GInterface(nodeId, logicalConnPoint);
+ default:
+ return null;
+ }
+
+ }
+
+ public String createOpenRoadmEth100GInterface(String nodeId,
+ String logicalConnPoint) throws OpenRoadmInterfaceException {
+
+ switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
+ case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
+ LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+ LOG.warn("Use Ethernet interface creation for 2.2.1, instead this method of Ether 100G");
+ return openRoadmInterface221.createOpenRoadmEthInterface(nodeId, logicalConnPoint);
+ case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
+ return openRoadmOtnInterface710.createOpenRoadmEth100GInterface(nodeId, logicalConnPoint);
default:
return null;
}
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmOtnInterface.createOpenRoadmOdu0Interface(
+ return openRoadmOtnInterface221.createOpenRoadmOdu0Interface(
nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlot);
default:
return null;
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmOtnInterface.createOpenRoadmOdu2Interface(
+ return openRoadmOtnInterface221.createOpenRoadmOdu2Interface(
nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
default:
return null;
LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
return null;
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmOtnInterface.createOpenRoadmOdu2eInterface(
+ return openRoadmOtnInterface221.createOpenRoadmOdu2eInterface(
nodeId, logicalConnPoint, servicename, payLoad, isNetworkPort, tribPortNumber, tribSlotIndex);
default:
return null;
}
+ public String createOpenRoadmOtnOdu4LoInterface(String nodeId, String logicalConnPoint,
+ String serviceName, String payLoad, boolean isNetworkPort,
+ OpucnTribSlotDef minTribSlotNumber, OpucnTribSlotDef maxTribSlotNumber)
+ throws OpenRoadmInterfaceException {
+
+ switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
+ case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
+ LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_1_2_1_MSG);
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
+ LOG.error(OTN_FUNTIONS_ARE_NOT_SUPPORTED_BY_OPENROADM_MODELS_2_2_1_MSG);
+ return null;
+ case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
+ return openRoadmOtnInterface710.createOpenRoadmOdu4Interface(nodeId, logicalConnPoint, serviceName,
+ payLoad, isNetworkPort, minTribSlotNumber, maxTribSlotNumber);
+ default:
+ return null;
+ }
+ }
+
public String createOpenRoadmOtnOdu4Interface(String nodeId, String logicalConnPoint, String supportingOtuInterface)
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
return null;
}
}
+
+ public String createOpenRoadmOtnOduc4Interface(String nodeId, String logicalConnPoint,
+ String supportingOtuInterface)
+ throws OpenRoadmInterfaceException {
+ switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
+ case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
+ return openRoadmInterface710
+ .createOpenRoadmOtnOducnInterface(nodeId, logicalConnPoint, supportingOtuInterface);
+ default:
+ return null;
+ }
+ }
+
+ public String createOpenRoadmOtnOduc4Interface(String anodeId, String alogicalConnPoint,
+ String asupportingOtuInterface, String znodeId, String zlogicalConnPoint)
+ throws OpenRoadmInterfaceException {
+ switch (mappingUtils.getOpenRoadmVersion(anodeId)) {
+ case StringConstants.OPENROADM_DEVICE_VERSION_7_1:
+ return openRoadmInterface710
+ .createOpenRoadmOtnOducnInterface(anodeId, alogicalConnPoint, asupportingOtuInterface,
+ znodeId, zlogicalConnPoint);
+ default:
+ return null;
+ }
+ }
}
--- /dev/null
+/*
+ * Copyright © 2021 AT&T and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+package org.opendaylight.transportpce.renderer.openroadminterface;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.stream.IntStream;
+import org.opendaylight.transportpce.common.mapping.PortMapping;
+import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
+import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.ParentOduAllocationBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.attributes.rev200327.parent.odu.allocation.parent.odu.allocation.trib.slots.choice.OpucnBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev200529.Off;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev200529.interfaces.grp.InterfaceKey;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.Interface1Builder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev200529.ethernet.container.EthernetBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.EthernetCsmacd;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.InterfaceType;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev191129.OtnOdu;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODU4;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUCTP;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUTTPCTP;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.PayloadTypeDef;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.OduAttributes.MonitoringMode;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.odu.container.OduBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.opu.OpuBuilder;
+import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class OpenRoadmOtnInterface710 {
+ private final PortMapping portMapping;
+ private final OpenRoadmInterfaces openRoadmInterfaces;
+ private static final Logger LOG = LoggerFactory
+ .getLogger(OpenRoadmOtnInterface710.class);
+
+ public OpenRoadmOtnInterface710(PortMapping portMapping,
+ OpenRoadmInterfaces openRoadmInterfaces) {
+ this.portMapping = portMapping;
+ this.openRoadmInterfaces = openRoadmInterfaces;
+ }
+
+ public String createOpenRoadmEth100GInterface(String nodeId,
+ String logicalConnPoint) throws OpenRoadmInterfaceException {
+
+ Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
+ if (portMap == null) {
+ throwException(nodeId, logicalConnPoint);
+ }
+
+ // Ethernet interface specific data
+ EthernetBuilder ethIfBuilder = new EthernetBuilder()
+ .setFec(Off.class)
+ .setSpeed(Uint32.valueOf(100000));
+ InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(
+ portMap, EthernetCsmacd.class,
+ logicalConnPoint + "-ETHERNET100G");
+ // Create Interface1 type object required for adding as augmentation
+ Interface1Builder ethIf1Builder = new Interface1Builder();
+ ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+ // Post interface on the device
+ this.openRoadmInterfaces.postOTNInterface(nodeId, ethInterfaceBldr);
+ // Post the equipment-state change on the device circuit-pack
+ this.openRoadmInterfaces.postOTNEquipmentState(nodeId,
+ portMap.getSupportingCircuitPackName(), true);
+ this.portMapping.updateMapping(nodeId, portMap);
+ String ethernetInterfaceName = ethInterfaceBldr.getName();
+
+ return ethernetInterfaceName;
+ }
+
+ private void throwException(String nodeId, String logicalConnPoint)
+ throws OpenRoadmInterfaceException {
+
+ throw new OpenRoadmInterfaceException(String.format(
+ "Unable to get mapping from PortMapping for node % and logical connection port %s",
+ nodeId, logicalConnPoint));
+ }
+
+ public String createOpenRoadmOdu4Interface(String nodeId, String logicalConnPoint,
+ String serviceName, String payLoad,
+ boolean isNetworkPort, OpucnTribSlotDef minTribSlotNumber, OpucnTribSlotDef maxTribSlotNumber)
+ throws OpenRoadmInterfaceException {
+ Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
+ if (portMap == null) {
+ throwException(nodeId, logicalConnPoint);
+ }
+ List<String> supportingInterfaceList = new ArrayList<>();
+ String supportingInterface = null;
+ if (isNetworkPort) {
+ supportingInterface = portMap.getSupportingOduc4();
+ } else {
+ supportingInterface = logicalConnPoint + "-ETHERNET100G";
+ }
+
+ if (supportingInterface == null) {
+ throw new OpenRoadmInterfaceException(
+ "Interface Creation failed because of missing supported "
+ + "ODU4 on network end or Ethernet on client");
+ }
+ // Supporting interface is a list for B100G (7.1) device models
+ supportingInterfaceList.add(supportingInterface);
+
+ InterfaceBuilder oduIfBuilder = createGenericInterfaceBuilder(
+ portMap, OtnOdu.class, logicalConnPoint + "-ODU4-" + serviceName)
+ .setSupportingInterfaceList(supportingInterfaceList);
+ // Agument ODU4 specific interface data
+ OduBuilder oduBuilder = new OduBuilder().setRate(ODU4.class)
+ .setOduFunction(ODUTTPCTP.class)
+ .setMonitoringMode(MonitoringMode.Terminated);
+ LOG.debug("Inside the ODU4 creation {} {} {}", isNetworkPort, minTribSlotNumber.getValue(),
+ maxTribSlotNumber.getValue());
+ // If it is a network port we have fill the required trib-slots and trib-ports
+ if (isNetworkPort) {
+ List<OpucnTribSlotDef> opucnTribSlotDefList = new ArrayList<>();
+ // Escape characters are used to here to take the literal dot
+ Uint16 tribPortNumber = Uint16.valueOf(minTribSlotNumber.getValue().split("\\.")[0]);
+ Uint16 startTribSlot = Uint16.valueOf(minTribSlotNumber.getValue().split("\\.")[1]);
+ Uint16 endTribSlot = Uint16.valueOf(maxTribSlotNumber.getValue().split("\\.")[1]);
+
+ IntStream.range(startTribSlot.intValue(), endTribSlot.intValue() + 1)
+ .forEach(
+ nbr -> opucnTribSlotDefList.add(OpucnTribSlotDef.getDefaultInstance(tribPortNumber + "." + nbr))
+ );
+ ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
+ .setTribPortNumber(tribPortNumber)
+ .setTribSlotsChoice(new OpucnBuilder().setOpucnTribSlots(opucnTribSlotDefList).build());
+ // reset the ODU function as ODUCTP and the monitoring moode
+ oduBuilder.setOduFunction(ODUCTP.class)
+ .setMonitoringMode(MonitoringMode.NotTerminated)
+ .setParentOduAllocation(parentOduAllocationBuilder.build());
+ }
+ else {
+ // This is for the client side of the ODU (ODU-TTP-CTP)
+ // Set Opu attributes
+ OpuBuilder opuBuilder = new OpuBuilder()
+ .setExpPayloadType(new PayloadTypeDef(payLoad))
+ .setPayloadType(new PayloadTypeDef(payLoad));
+ oduBuilder.setOpu(opuBuilder.build());
+ }
+
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder
+ oduIf1Builder = new
+ org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev200529.Interface1Builder();
+ oduIfBuilder.addAugmentation(oduIf1Builder.setOdu(oduBuilder.build()).build());
+ // Post interface on the device
+ this.openRoadmInterfaces.postOTNInterface(nodeId, oduIfBuilder);
+ LOG.info("Returning the ODU4 inteface {}", oduIfBuilder.getName());
+ return oduIfBuilder.getName();
+ }
+
+ private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap,
+ Class<? extends InterfaceType> type, String key) {
+ return new InterfaceBuilder()
+ // .setDescription(" TBD ")
+ // .setCircuitId(" TBD ")
+ .setSupportingCircuitPackName(
+ portMap.getSupportingCircuitPackName())
+ .setSupportingPort(portMap.getSupportingPort())
+ .setAdministrativeState(AdminStates.InService)
+ // TODO get rid of unchecked cast warning
+ .setType(type).setName(key).withKey(new InterfaceKey(key));
+ }
+}
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceBuilder;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceKey;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.olm.renderer.input.Nodes;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathOutputBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterface;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceBuilder;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.node.interfaces.NodeInterfaceKey;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.otn.renderer.input.Nodes;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
nodeInterfaces = createInterface(input);
LOG.info("Node interfaces created just fine ");
- List<String> nodesToUpdate = new ArrayList<>();
- if (!nodeInterfaces.isEmpty()) {
- for (NodeInterface nodeInterf : nodeInterfaces) {
- if (nodeInterf.getOduInterfaceId() != null) {
- List<String> interList = nodeInterf.getOduInterfaceId().stream()
- .filter(id -> id.contains("NETWORK")).collect(Collectors.toList());
- if (!interList.isEmpty()) {
- for (String inter : interList) {
- String tp = inter.split("-ODU")[0];
- String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0];
- nodesToUpdate.add(nodeTopo + "--" + tp);
- }
- }
- }
- }
- }
+ List<String> nodesToUpdate = updateOduNodes(nodeInterfaces, "ODU");
updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
input.getTribSlot(), false);
} catch (OpenRoadmInterfaceException e) {
LOG.warn("Set up service path failed", e);
success = false;
}
+ } else if ("100G".equals(input.getServiceRate())) {
+ try {
+ LOG.info("Calling Node interfaces {} {} {} {} {} {}",
+ input.getServiceRate(), input.getEthernetEncoding(),
+ input.getServiceType(), input.getOperation(), input.getOpucnTribSlots(), input.getNodes());
+ nodeInterfaces = createInterface(input);
+ LOG.info("Node interfaces created just fine for 100G OTN ");
+ // TODO: Update the OTN topology accordingly with Opucn-Trib-slots
+ // List<String> nodesToUpdate = updateOduNodes(nodeInterfaces, "ODUC4");
+ // updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
+ // input.getTribSlot(), false);
+ } catch (OpenRoadmInterfaceException e) {
+ LOG.warn("Set up service path failed", e);
+ success = false;
+ }
} else {
LOG.warn("Unsupported service-rate for service-type Ethernet");
}
LOG.warn("Set up service path failed", e);
success = false;
}
+ } else if ("400G".equals(input.getServiceRate())) {
+ try {
+ createOduc4TtpInterface(input, nodeInterfaces, otnNodesProvisioned);
+ updateOtnTopology(otnNodesProvisioned, null, null, null, null, false);
+ } catch (OpenRoadmInterfaceException e) {
+ LOG.warn("Set up service path failed", e);
+ success = false;
+ }
} else {
LOG.warn("Unsupported service-rate for service-type ODU");
}
}
}
+ private List<String> updateOduNodes(List<NodeInterface> nodeInterfaceList, String deLimiter) {
+ List<String> nodesToUpdate = new ArrayList<>();
+ if (!(deLimiter.equals("ODU")) || !(deLimiter.equals("ODUC4"))) {
+ LOG.error("ODU node list update will be incorrect");
+ }
+
+ if (!nodeInterfaceList.isEmpty()) {
+ for (NodeInterface nodeInterf : nodeInterfaceList) {
+ if (nodeInterf.getOduInterfaceId() != null) {
+ List<String> interList = nodeInterf.getOduInterfaceId().stream()
+ .filter(id -> id.contains("NETWORK")).collect(Collectors.toList());
+ if (!interList.isEmpty()) {
+ for (String inter : interList) {
+ String tp = inter.split("-" + deLimiter)[0];
+ String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0];
+ nodesToUpdate.add(nodeTopo + "--" + tp);
+ }
+ }
+ }
+ }
+ }
+
+ return nodesToUpdate;
+ }
+
private List<NodeInterface> createInterface(OtnServicePathInput input) throws OpenRoadmInterfaceException {
List<NodeInterface> nodeInterfaces = new ArrayList<>();
LOG.info("Calling Create Interface entry for OTN service path");
if (input.getServiceRate() == null
- || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate()))) {
+ || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate())
+ || "100G".equals(input.getServiceRate()))) {
LOG.error("Service rate {} not managed yet", input.getServiceRate());
} else {
createLowOrderInterfaces(input, nodeInterfaces);
input.getTribSlot()));
}
break;
+ case ("100G"):
+ LOG.info("Input service is 100G");
+ // Take the first and last value in the list of OpucnTribSlot (assuming SH would provide
+ // min and max value only, size two)
+ OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef.getDefaultInstance(
+ input.getOpucnTribSlots().get(0).getValue());
+ OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef.getDefaultInstance(
+ input.getOpucnTribSlots().get(1).getValue());
+ if (node.getClientTp() != null) {
+ createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth100GInterface(
+ node.getNodeId(), node.getClientTp()));
+ // OPUCn trib information is optional when creating ODU4 ethernet (client) interface
+ createdOduInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
+ node.getClientTp(), input.getServiceName(), PT_07, false, minOpucnTs,
+ maxOpucnTs));
+ }
+ // Here payload-type is optional and is not used for interface creation (especially for network)
+ createdOduInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
+ node.getNetworkTp(), input.getServiceName(), PT_07, true, minOpucnTs,
+ maxOpucnTs));
+ // Here payload-type is optional and is not used for service creation
+ // This is needed if there is an intermediate node
+ if (node.getNetwork2Tp() != null) {
+ createdOduInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
+ node.getNetwork2Tp(), input.getServiceName(), PT_07, true, minOpucnTs,
+ maxOpucnTs));
+ }
+ break;
default:
LOG.error("service rate {} not managed yet", input.getServiceRate());
return;
}
}
+ private void createOduc4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
+ CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
+ if (input.getNodes() == null) {
+ return;
+ }
+ LOG.info("Creation of ODUC4 TTP interface in OTN service path {}", input);
+ for (int i = 0; i < input.getNodes().size(); i++) {
+ Nodes node = input.getNodes().get(i);
+ String supportingOtuInterface = node.getNetworkTp() + "-OTUC4";
+ List<String> createdOduc4Interfaces = new ArrayList<>();
+ // Adding SAPI/DAPI information to the
+ Nodes tgtNode = null;
+ if (i + 1 == input.getNodes().size()) {
+ // For the end node, tgtNode becomes the first node in the list
+ tgtNode = input.getNodes().get(0);
+ } else {
+ tgtNode = input.getNodes().get(i + 1);
+ }
+ createdOduc4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(),
+ node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
+
+ NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
+ .withKey(new NodeInterfaceKey(node.getNodeId()))
+ .setNodeId(node.getNodeId())
+ .setOduInterfaceId(createdOduc4Interfaces); // though this is odu, actually it has ODUC4 interfaces
+ nodeInterfaces.add(nodeInterfaceBuilder.build());
+ otnNodesProvisioned.add(node);
+ }
+ }
+
private void createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
if (input.getNodes() == null) {
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestOutput;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ConnectionType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODU4;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.ODUCn;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OTU4;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OTUCn;
import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity;
import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat;
case Service: case RoadmLine: // This takes into account of Ethernet 100G, 1G, 10G and ODU4
LOG.info("RPC implementation for {}", input.getConnectionType());
if (((input.getServiceAEnd().getServiceRate() != null)
- && (input.getServiceAEnd().getServiceRate().intValue() == 100))
+ && ((input.getServiceAEnd().getServiceRate().intValue() == 100))
+ || (input.getServiceAEnd().getServiceRate().intValue() == 400))
&& ((input.getServiceAEnd().getServiceFormat().getName().equals("Ethernet"))
|| (input.getServiceAEnd().getServiceFormat().getName().equals("OC")))) {
LOG.info("Service format for {} is {} and rate is {}", input.getServiceName(),
OPERATION_FAILED);
}
} else { // This implies, service-rate is 1 or 10G
- // This includes the lower-order odu (1G, 10G) and this is A-Z side
+ // This includes the lower-order odu (1G, 10G, 100G) and this is A-Z side
LOG.info("RPC implementation for LO-ODU");
String serviceRate = ""; // Assuming service at A-side and Z-side has same service rate
if (input.getServiceAEnd().getServiceRate() != null) {
break;
case Infrastructure:
LOG.info("RPC implementation for {}", input.getConnectionType());
- if ((input.getServiceAEnd().getOtuServiceRate() != null)
- && (input.getServiceAEnd().getOtuServiceRate().equals(OTU4.class))) {
- // For the service of OTU4 infrastructure
- // First create the OCH and OTU interfaces
- String serviceRate = "100G"; // For OtnDeviceRendererServiceImpl
- if (!createServicepathInput(input)) {
- return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
- OPERATION_FAILED);
+ if (input.getServiceAEnd().getOtuServiceRate() != null) {
+ if ((input.getServiceAEnd().getOtuServiceRate().equals(OTU4.class))
+ || (input.getServiceAEnd().getOtuServiceRate().equals(OTUCn.class))) {
+ // For the service of OTU4 or OTUCn infrastructure
+ // Create the OCH and OTU interfaces for OTU4 class
+ // Create OTSi, OTSi-group and OTUCn interface
+ if (!createServicepathInput(input)) {
+ return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
+ OPERATION_FAILED);
+ }
}
}
- if ((input.getServiceAEnd().getOduServiceRate() != null)
- && (input.getServiceAEnd().getOduServiceRate().equals(ODU4.class))) {
- // For the service of OTU4 infrastructure
- String serviceRate = "100G"; // For OtnDeviceRendererServiceImpl
+ if (input.getServiceAEnd().getOduServiceRate() != null) {
+ String serviceRate = null;
+ if (input.getServiceAEnd().getOduServiceRate().equals(ODU4.class)) {
+ // For the service of OTU4 infrastructure
+ serviceRate = "100G"; // For OtnDeviceRendererServiceImpl
+ }
+ else if (input.getServiceAEnd().getOduServiceRate().equals(ODUCn.class)) {
+ // For the service of OTUCn infrastructure
+ // TODO: what happens if split-lambda where to be used? We will have ODUC2 rate,
+ // TODO: which case service-rate would be 200
+ // TODO: in that case it would be 200G?? Need to understand more
+ serviceRate = "400G"; // For OtnDeviceRendererServiceImpl
+ }
LOG.info("Service format for {} is {} and rate is {}", input.getServiceName(),
input.getServiceAEnd().getOduServiceRate(), serviceRate);
- // Now start rendering ODU4 interface
+ // Now start rendering ODU4 or ODUC4 interface
// This is A-Z side
OtnServicePathInput otnServicePathInputAtoZ = ModelMappingUtils
.rendererCreateOtnServiceInput(input.getServiceName(),
<argument ref="openRoadmInterfaces"/>
</bean>
- <bean id="openRoadmOtnInterface"
+ <bean id="openRoadmOtnInterface221"
class="org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221">
<argument ref="portMapping"/>
<argument ref="openRoadmInterfaces"/>
</bean>
+ <bean id="openRoadmOtnInterface710"
+ class="org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710">
+ <argument ref="portMapping"/>
+ <argument ref="openRoadmInterfaces"/>
+ </bean>
+
<bean id="openRoadmInterfaceFactory"
class="org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory">
<argument ref="mappingUtils"/>
<argument ref="openRoadmInterface121"/>
<argument ref="openRoadmInterface221"/>
<argument ref="openRoadmInterface710"/>
- <argument ref="openRoadmOtnInterface"/>
+ <argument ref="openRoadmOtnInterface221"/>
+ <argument ref="openRoadmOtnInterface710"/>
</bean>
<bean id="deviceRenderer" class="org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererServiceImpl" >
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710;
import org.opendaylight.transportpce.renderer.utils.CreateOtsOmsDataUtils;
import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
import org.opendaylight.transportpce.test.AbstractTest;
private PortMappingVersion121 portMappingVersion121;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl221;
+ private CrossConnectImpl710 crossConnectImpl710;
private void setMountPoint(MountPoint mountPoint) {
MountPointService mountPointService = new MountPointServiceStub(mountPoint);
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping, openRoadmInterfaces);
- OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
+ OpenRoadmOtnInterface221 openRoadmOTNInterface221 = new OpenRoadmOtnInterface221(portMapping,
+ openRoadmInterfaces);
+ OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping,
+ openRoadmInterfaces);
this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121,
- openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface);
+ openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface221, openRoadmOtnInterface710);
this.crossConnectImpl121 = new CrossConnectImpl121(this.deviceTransactionManager);
this.crossConnectImpl221 = new CrossConnectImpl221(this.deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(this.deviceTransactionManager, this.mappingUtils,
- this.crossConnectImpl121, this.crossConnectImpl221);
+ this.crossConnectImpl121, this.crossConnectImpl221, this.crossConnectImpl710);
this.crossConnect = Mockito.spy(this.crossConnect);
this.deviceRendererService = new DeviceRendererServiceImpl(this.getDataBroker(),
this.deviceTransactionManager, this.openRoadmInterfaceFactory, this.openRoadmInterfaces,
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710;
import org.opendaylight.transportpce.renderer.stub.OlmServiceStub;
import org.opendaylight.transportpce.renderer.utils.NotificationPublishServiceMock;
import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils;
private PortMappingVersion121 portMappingVersion121;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl221;
+ private CrossConnectImpl710 crossConnectImpl710;
private OtnDeviceRendererService otnDeviceRendererService;
private void setMountPoint(MountPoint mountPoint) {
this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
this.crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
- this.crossConnectImpl221);
+ this.crossConnectImpl221, this.crossConnectImpl710);
this.crossConnect = Mockito.spy(crossConnect);
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping,openRoadmInterfaces);
- OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
+ OpenRoadmOtnInterface221 openRoadmOTNInterface221 = new OpenRoadmOtnInterface221(portMapping,
+ openRoadmInterfaces);
+ OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping,
+ openRoadmInterfaces);
OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,
- openRoadmInterface121, openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface);
+ openRoadmInterface121, openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface221,
+ openRoadmOtnInterface710);
this.deviceRenderer = new DeviceRendererServiceImpl(getDataBroker(),
this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect,
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
+import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl710;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface710;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface221;
+import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmOtnInterface710;
import org.opendaylight.transportpce.renderer.stub.OlmServiceStub;
import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
import org.opendaylight.transportpce.renderer.utils.NotificationPublishServiceMock;
private PortMappingVersion121 portMappingVersion121;
private CrossConnectImpl121 crossConnectImpl121;
private CrossConnectImpl221 crossConnectImpl221;
+ private CrossConnectImpl710 crossConnectImpl710;
private void setMountPoint(MountPoint mountPoint) {
this.mountPointService = new MountPointServiceStub(mountPoint);
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
OpenRoadmInterface710 openRoadmInterface710 = new OpenRoadmInterface710(portMapping,openRoadmInterfaces);
- OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
+ OpenRoadmOtnInterface221 openRoadmOTNInterface221 = new OpenRoadmOtnInterface221(portMapping,
+ openRoadmInterfaces);
+ OpenRoadmOtnInterface710 openRoadmOtnInterface710 = new OpenRoadmOtnInterface710(portMapping,
+ openRoadmInterfaces);
this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121,
- openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface);
+ openRoadmInterface221, openRoadmInterface710, openRoadmOTNInterface221, openRoadmOtnInterface710);
this.crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
this.crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager);
this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
- this.crossConnectImpl221);
+ this.crossConnectImpl221, this.crossConnectImpl710);
}
@Before
for (TerminationPoint tp : this.oorNetworkPortList) {
TpId tpid1 = tp.getTpId();
TpId tpid2 = new TpId(tp.augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
.getAssociatedConnectionMapPort());
List<TpId> tpList = new ArrayList<>();
tpList.add(tpid1);
for (TerminationPoint tp : this.oorNetworkPortList) {
TpId tpid1 = tp.getTpId();
TpId tpid2 = new TpId(tp.augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
.getAssociatedConnectionMapPort());
List<TpId> tpList = new ArrayList<>();
tpList.add(tpid1);
String networkLcp;
if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERCLIENT)) {
networkLcp = tp.augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
.getAssociatedConnectionMapPort();
} else {
networkLcp = tp.getTpId().getValue();
String networkLcp;
if (tp.augmentation(TerminationPoint1.class).getTpType().equals(OpenroadmTpType.XPONDERCLIENT)) {
networkLcp = tp.augmentation(
- org.opendaylight.yang.gen.v1.http.transportpce.topology.rev201019.TerminationPoint1.class)
+ org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.TerminationPoint1.class)
.getAssociatedConnectionMapPort();
} else {
networkLcp = tp.getTpId().getValue();
--- /dev/null
+{
+ "network": [
+ {
+ "network-id": "otn-topology",
+ "network-types": {
+ "org-openroadm-common-network:openroadm-common-network": {}
+ },
+ "node": [
+ {
+ "node-id": "XPDR-A2-XPDR1",
+ "org-openroadm-common-network:node-type": "TPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 1
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-400GE"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR1",
+ "tp-ref": "XPDR1-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR1"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-C2-XPDR1",
+ "org-openroadm-common-network:node-type": "TPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 1
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-400GE"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR1",
+ "tp-ref": "XPDR1-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR1"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-A2-XPDR2",
+ "org-openroadm-common-network:node-type": "MUXPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 2
+ },
+ "org-openroadm-otn-network-topology:switching-pools": {
+ "odu-switching-pools": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "non-blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 1,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT1"
+ ],
+ "available-interconnect-bandwidth": 10
+ },
+ {
+ "nbl-number": 2,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-CLIENT2",
+ "XPDR2-NETWORK1"
+ ],
+ "available-interconnect-bandwidth": 10
+ }
+ ]
+ }
+ ]
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR2",
+ "tp-ref": "XPDR2-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT2",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR2"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-C2-XPDR2",
+ "org-openroadm-common-network:node-type": "MUXPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 2
+ },
+ "org-openroadm-otn-network-topology:switching-pools": {
+ "odu-switching-pools": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "non-blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 1,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT1"
+ ],
+ "available-interconnect-bandwidth": 10
+ },
+ {
+ "nbl-number": 2,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-CLIENT2",
+ "XPDR2-NETWORK1"
+ ],
+ "available-interconnect-bandwidth": 10
+ }
+ ]
+ }
+ ]
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR2",
+ "tp-ref": "XPDR2-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT2",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
--- /dev/null
+{
+ "network": [
+ {
+ "network-id": "otn-topology",
+ "network-types": {
+ "org-openroadm-common-network:openroadm-common-network": {}
+ },
+ "node": [
+ {
+ "node-id": "XPDR-A2-XPDR1",
+ "org-openroadm-common-network:node-type": "TPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 1
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-400GE"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR1",
+ "tp-ref": "XPDR1-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR1"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-C2-XPDR1",
+ "org-openroadm-common-network:node-type": "TPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 1
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-400GE"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR1",
+ "tp-ref": "XPDR1-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR1"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-A2-XPDR2",
+ "org-openroadm-common-network:node-type": "MUXPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 2
+ },
+ "org-openroadm-otn-network-topology:switching-pools": {
+ "odu-switching-pools": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "non-blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 1,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT1"
+ ],
+ "available-interconnect-bandwidth": 10
+ },
+ {
+ "nbl-number": 2,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-CLIENT2",
+ "XPDR2-NETWORK1"
+ ],
+ "available-interconnect-bandwidth": 10
+ }
+ ]
+ }
+ ]
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR2",
+ "tp-ref": "XPDR2-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODUCn",
+ "ts-pool": [
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9,
+ 10,
+ 15,
+ 16,
+ 13,
+ 14,
+ 19,
+ 20,
+ 17,
+ 18,
+ 11,
+ 12,
+ 31,
+ 32,
+ 29,
+ 30,
+ 35,
+ 36,
+ 33,
+ 34,
+ 23,
+ 24,
+ 21,
+ 22,
+ 27,
+ 28,
+ 25,
+ 26,
+ 47,
+ 48,
+ 45,
+ 46,
+ 51,
+ 52,
+ 49,
+ 50,
+ 39,
+ 40,
+ 37,
+ 38,
+ 43,
+ 44,
+ 41,
+ 42,
+ 63,
+ 64,
+ 61,
+ 62,
+ 67,
+ 68,
+ 65,
+ 66,
+ 55,
+ 56,
+ 53,
+ 54,
+ 59,
+ 60,
+ 57,
+ 58,
+ 79,
+ 80,
+ 77,
+ 78,
+ 71,
+ 72,
+ 69,
+ 70,
+ 75,
+ 76,
+ 73,
+ 74
+ ],
+ "odtu-tpn-pool": [
+ {
+ "odtu-type": "org-openroadm-otn-common-types:ODTUCn.ts",
+ "tpn-pool": [
+ 1,
+ 3,
+ 2,
+ 4
+ ]
+ }
+ ]
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT2",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR2"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-C2-XPDR2",
+ "org-openroadm-common-network:node-type": "MUXPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 2
+ },
+ "org-openroadm-otn-network-topology:switching-pools": {
+ "odu-switching-pools": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "non-blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 1,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT1"
+ ],
+ "available-interconnect-bandwidth": 10
+ },
+ {
+ "nbl-number": 2,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-CLIENT2",
+ "XPDR2-NETWORK1"
+ ],
+ "available-interconnect-bandwidth": 10
+ }
+ ]
+ }
+ ]
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR2",
+ "tp-ref": "XPDR2-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODUCn",
+ "ts-pool": [
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 6,
+ 7,
+ 8,
+ 9,
+ 10,
+ 15,
+ 16,
+ 13,
+ 14,
+ 19,
+ 20,
+ 17,
+ 18,
+ 11,
+ 12,
+ 31,
+ 32,
+ 29,
+ 30,
+ 35,
+ 36,
+ 33,
+ 34,
+ 23,
+ 24,
+ 21,
+ 22,
+ 27,
+ 28,
+ 25,
+ 26,
+ 47,
+ 48,
+ 45,
+ 46,
+ 51,
+ 52,
+ 49,
+ 50,
+ 39,
+ 40,
+ 37,
+ 38,
+ 43,
+ 44,
+ 41,
+ 42,
+ 63,
+ 64,
+ 61,
+ 62,
+ 67,
+ 68,
+ 65,
+ 66,
+ 55,
+ 56,
+ 53,
+ 54,
+ 59,
+ 60,
+ 57,
+ 58,
+ 79,
+ 80,
+ 77,
+ 78,
+ 71,
+ 72,
+ 69,
+ 70,
+ 75,
+ 76,
+ 73,
+ 74
+ ],
+ "odtu-tpn-pool": [
+ {
+ "odtu-type": "org-openroadm-otn-common-types:ODTUCn.ts",
+ "tpn-pool": [
+ 1,
+ 3,
+ 2,
+ 4
+ ]
+ }
+ ]
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT2",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ }
+ ]
+ }
+ ],
+ "ietf-network-topology:link": [
+ {
+ "link-id": "OTUC4-XPDR-A2-XPDR2-XPDR2-NETWORK1toXPDR-C2-XPDR2-XPDR2-NETWORK1",
+ "source": {
+ "source-node": "XPDR-A2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
+ },
+ "destination": {
+ "dest-node": "XPDR-C2-XPDR2",
+ "dest-tp": "XPDR2-NETWORK1"
+ },
+ "org-openroadm-otn-network-topology:available-bandwidth": "0",
+ "org-openroadm-otn-network-topology:used-bandwidth": "400000",
+ "org-openroadm-common-network:link-type": "OTN-LINK",
+ "transportpce-topology:otn-link-type": "OTUC4",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:opposite-link": "OTUC4-XPDR-C2-XPDR2-XPDR2-NETWORK1toXPDR-A2-XPDR2-XPDR2-NETWORK1"
+ },
+ {
+ "link-id": "OTUC4-XPDR-C2-XPDR2-XPDR2-NETWORK1toXPDR-A2-XPDR2-XPDR2-NETWORK1",
+ "source": {
+ "source-node": "XPDR-C2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
+ },
+ "destination": {
+ "dest-node": "XPDR-A2-XPDR2",
+ "dest-tp": "XPDR2-NETWORK1"
+ },
+ "org-openroadm-otn-network-topology:available-bandwidth": "0",
+ "org-openroadm-otn-network-topology:used-bandwidth": "400000",
+ "org-openroadm-common-network:link-type": "OTN-LINK",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "transportpce-topology:otn-link-type": "OTUC4",
+ "org-openroadm-common-network:opposite-link": "OTUC4-XPDR-A2-XPDR2-XPDR2-NETWORK1toXPDR-C2-XPDR2-XPDR2-NETWORK1"
+ },
+ {
+ "link-id": "ODUC4-XPDR-A2-XPDR2-XPDR2-NETWORK1toXPDR-C2-XPDR2-XPDR2-NETWORK1",
+ "source": {
+ "source-node": "XPDR-A2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
+ },
+ "destination": {
+ "dest-node": "XPDR-C2-XPDR2",
+ "dest-tp": "XPDR2-NETWORK1"
+ },
+ "org-openroadm-otn-network-topology:available-bandwidth": "400000",
+ "org-openroadm-otn-network-topology:used-bandwidth": "0",
+ "org-openroadm-common-network:link-type": "OTN-LINK",
+ "transportpce-topology:otn-link-type": "ODUC4",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ODUC4-XPDR-C2-XPDR2-XPDR2-NETWORK1toXPDR-A2-XPDR2-XPDR2-NETWORK1"
+ },
+ {
+ "link-id": "ODUC4-XPDR-C2-XPDR2-XPDR2-NETWORK1toXPDR-A2-XPDR2-XPDR2-NETWORK1",
+ "source": {
+ "source-node": "XPDR-C2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
+ },
+ "destination": {
+ "dest-node": "XPDR-A2-XPDR2",
+ "dest-tp": "XPDR2-NETWORK1"
+ },
+ "org-openroadm-otn-network-topology:available-bandwidth": "400000",
+ "org-openroadm-otn-network-topology:used-bandwidth": "0",
+ "org-openroadm-common-network:link-type": "OTN-LINK",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "transportpce-topology:otn-link-type": "ODUC4",
+ "org-openroadm-common-network:opposite-link": "ODUC4-XPDR-A2-XPDR2-XPDR2-NETWORK1toXPDR-C2-XPDR2-XPDR2-NETWORK1"
+ }
+ ]
+ }
+ ]
+}
--- /dev/null
+{
+ "network": [
+ {
+ "network-id": "otn-topology",
+ "network-types": {
+ "org-openroadm-common-network:openroadm-common-network": {}
+ },
+ "node": [
+ {
+ "node-id": "XPDR-A2-XPDR1",
+ "org-openroadm-common-network:node-type": "TPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 1
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-400GE"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR1",
+ "tp-ref": "XPDR1-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR1"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-C2-XPDR1",
+ "org-openroadm-common-network:node-type": "TPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 1
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-400GE"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR1",
+ "tp-ref": "XPDR1-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR1"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-A2-XPDR2",
+ "org-openroadm-common-network:node-type": "MUXPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 2
+ },
+ "org-openroadm-otn-network-topology:switching-pools": {
+ "odu-switching-pools": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "non-blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 1,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT1"
+ ],
+ "available-interconnect-bandwidth": 10
+ },
+ {
+ "nbl-number": 2,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-CLIENT2",
+ "XPDR2-NETWORK1"
+ ],
+ "available-interconnect-bandwidth": 10
+ }
+ ]
+ }
+ ]
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR2",
+ "tp-ref": "XPDR2-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT2",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-A2-XPDR2"
+ }
+ ]
+ },
+ {
+ "node-id": "XPDR-C2-XPDR2",
+ "org-openroadm-common-network:node-type": "MUXPDR",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-otn-network-topology:xpdr-attributes": {
+ "xpdr-number": 2
+ },
+ "org-openroadm-otn-network-topology:switching-pools": {
+ "odu-switching-pools": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "non-blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 1,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT1"
+ ],
+ "available-interconnect-bandwidth": 10
+ },
+ {
+ "nbl-number": 2,
+ "interconnect-bandwidth-unit": 1000000000,
+ "tp-list": [
+ "XPDR2-CLIENT2",
+ "XPDR2-NETWORK1"
+ ],
+ "available-interconnect-bandwidth": 10
+ }
+ ]
+ }
+ ]
+ },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "supporting-termination-point": [
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR2",
+ "tp-ref": "XPDR2-NETWORK1"
+ }
+ ],
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-otsi-otsigroup"
+ }
+ ]
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT1",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ },
+ {
+ "tp-id": "XPDR2-CLIENT2",
+ "org-openroadm-otn-network-topology:tp-supported-interfaces": {
+ "supported-interface-capability": [
+ {
+ "if-cap-type": "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ },
+ {
+ "if-cap-type": "org-openroadm-port-types:if-100GE-ODU4"
+ }
+ ]
+ },
+ "org-openroadm-otn-network-topology:xpdr-tp-port-connection-attributes": {
+ "rate": "org-openroadm-otn-common-types:ODU4"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "openroadm-topology",
+ "node-ref": "XPDR-C2-XPDR2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ }
+ ]
+ }
+ ],
+ "ietf-network-topology:link": [
+ {
+ "link-id": "OTUC4-XPDR-A2-XPDR2-XPDR2-NETWORK1toXPDR-C2-XPDR2-XPDR2-NETWORK1",
+ "source": {
+ "source-node": "XPDR-A2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
+ },
+ "destination": {
+ "dest-node": "XPDR-C2-XPDR2",
+ "dest-tp": "XPDR2-NETWORK1"
+ },
+ "org-openroadm-otn-network-topology:available-bandwidth": "400000",
+ "org-openroadm-otn-network-topology:used-bandwidth": "0",
+ "org-openroadm-common-network:link-type": "OTN-LINK",
+ "transportpce-topology:otn-link-type": "OTUC4",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:opposite-link": "OTUC4-XPDR-C2-XPDR2-XPDR2-NETWORK1toXPDR-A2-XPDR2-XPDR2-NETWORK1"
+ },
+ {
+ "link-id": "OTUC4-XPDR-C2-XPDR2-XPDR2-NETWORK1toXPDR-A2-XPDR2-XPDR2-NETWORK1",
+ "source": {
+ "source-node": "XPDR-C2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
+ },
+ "destination": {
+ "dest-node": "XPDR-A2-XPDR2",
+ "dest-tp": "XPDR2-NETWORK1"
+ },
+ "org-openroadm-otn-network-topology:available-bandwidth": "400000",
+ "org-openroadm-otn-network-topology:used-bandwidth": "0",
+ "org-openroadm-common-network:link-type": "OTN-LINK",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "transportpce-topology:otn-link-type": "OTUC4",
+ "org-openroadm-common-network:opposite-link": "OTUC4-XPDR-A2-XPDR2-XPDR2-NETWORK1toXPDR-C2-XPDR2-XPDR2-NETWORK1"
+ }
+ ]
+ }
+ ]
+}
\ No newline at end of file
"network": [
{
"network-id": "openroadm-topology",
- "ietf-network-topology:link": [
- {
- "link-id": "XPDR-C2-XPDR1-XPDR1-NETWORK1toROADM-C1-SRG1-SRG1-PP4-TXRX",
- "source": {
- "source-node": "XPDR-C2-XPDR1",
- "source-tp": "XPDR1-NETWORK1"
- },
- "org-openroadm-common-network:link-type": "XPONDER-OUTPUT",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-PP4-TXRXtoXPDR-C2-XPDR1-XPDR1-NETWORK1",
- "org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "SRG1-PP4-TXRX",
- "dest-node": "ROADM-C1-SRG1"
- }
- },
+ "network-types": {
+ "org-openroadm-common-network:openroadm-common-network": {}
+ },
+ "node": [
{
- "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX",
- "source": {
- "source-node": "ROADM-A1-DEG2",
- "source-tp": "DEG2-TTP-TXRX"
- },
- "org-openroadm-common-network:link-type": "ROADM-TO-ROADM",
+ "node-id": "ROADM-A1-SRG3",
+ "org-openroadm-common-network:node-type": "SRG",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "DEG1-TTP-TXRX",
- "dest-node": "ROADM-C1-DEG1"
- },
- "org-openroadm-network-topology:OMS-attributes": {
- "span": {
- "auto-spanloss": true,
- "spanloss-current": 12,
- "engineered-spanloss": 12.2,
- "spanloss-base": 11.4,
- "link-concatenation": [
- {
- "SRLG-Id": 0,
- "fiber-type": "smf",
- "pmd": 0.5,
- "SRLG-length": 100000
- }
- ]
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "SRG3-PP3-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG3-PP2-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG3-CP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-CP"
+ },
+ {
+ "tp-id": "SRG3-PP1-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG3-PP4-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
}
- }
- },
- {
- "link-id": "XPDR-C1-XPDR1-XPDR1-NETWORK1toROADM-C1-SRG1-SRG1-PP1-TXRX",
- "source": {
- "source-node": "XPDR-C1-XPDR1",
- "source-tp": "XPDR1-NETWORK1"
+ ],
+ "org-openroadm-network-topology:srg-attributes": {
+ "avail-freq-maps": [
+ {
+ "map-name": "cband",
+ "freq-map-granularity": 6.25,
+ "start-edge-freq": 191.325,
+ "effective-bits": 768,
+ "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+ }
+ ]
},
- "org-openroadm-common-network:link-type": "XPONDER-OUTPUT",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-PP1-TXRXtoXPDR-C1-XPDR1-XPDR1-NETWORK1",
- "org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "SRG1-PP1-TXRX",
- "dest-node": "ROADM-C1-SRG1"
- }
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "ROADM-A1"
+ }
+ ]
},
{
- "link-id": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
- "source": {
- "source-node": "ROADM-C1-DEG1",
- "source-tp": "DEG1-CTP-TXRX"
- },
- "org-openroadm-common-network:link-type": "DROP-LINK",
+ "node-id": "XPDR-A2-XPDR1",
+ "org-openroadm-common-network:node-type": "XPONDER",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "SRG1-CP-TXRX",
- "dest-node": "ROADM-C1-SRG1"
- }
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT",
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "org-openroadm-network-topology:xpdr-network-attributes": {
+ "tail-equipment-id": "ROADM-A1-SRG1--SRG1-PP1-TXRX"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK",
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ }
+ ]
},
{
- "link-id": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
- "source": {
- "source-node": "ROADM-A1-SRG3",
- "source-tp": "SRG3-CP-TXRX"
- },
- "org-openroadm-common-network:link-type": "ADD-LINK",
+ "node-id": "XPDR-C2-XPDR1",
+ "org-openroadm-common-network:node-type": "XPONDER",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "DEG1-CTP-TXRX",
- "dest-node": "ROADM-A1-DEG1"
- }
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR1-CLIENT1",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-CLIENT",
+ "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1"
+ },
+ {
+ "tp-id": "XPDR1-NETWORK1",
+ "org-openroadm-network-topology:xpdr-network-attributes": {
+ "tail-equipment-id": "ROADM-C1-SRG1--SRG1-PP1-TXRX"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK",
+ "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ }
+ ]
},
{
- "link-id": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
- "source": {
- "source-node": "ROADM-A1-SRG3",
- "source-tp": "SRG3-CP-TXRX"
- },
- "org-openroadm-common-network:link-type": "ADD-LINK",
+ "node-id": "XPDR-A2-XPDR2",
+ "org-openroadm-common-network:node-type": "XPONDER",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "DEG2-CTP-TXRX",
- "dest-node": "ROADM-A1-DEG2"
- }
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "org-openroadm-network-topology:xpdr-network-attributes": {
+ "tail-equipment-id": "ROADM-A1-SRG1--SRG1-PP2-TXRX"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-A2"
+ }
+ ]
},
{
- "link-id": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
- "source": {
- "source-node": "ROADM-A1-DEG1",
- "source-tp": "DEG1-CTP-TXRX"
- },
- "org-openroadm-common-network:link-type": "DROP-LINK",
+ "node-id": "XPDR-C2-XPDR2",
+ "org-openroadm-common-network:node-type": "XPONDER",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "SRG3-CP-TXRX",
- "dest-node": "ROADM-A1-SRG3"
- }
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "XPDR2-NETWORK1",
+ "org-openroadm-network-topology:xpdr-network-attributes": {
+ "tail-equipment-id": "ROADM-C1-SRG1--SRG1-PP2-TXRX"
+ },
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
+ }
+ ],
+ "supporting-node": [
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "XPDR-C2"
+ },
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ }
+ ]
},
{
- "link-id": "ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1",
- "source": {
- "source-node": "ROADM-A1-SRG1",
- "source-tp": "SRG1-PP1-TXRX"
- },
- "org-openroadm-common-network:link-type": "XPONDER-INPUT",
+ "node-id": "ROADM-C1-SRG1",
+ "org-openroadm-common-network:node-type": "SRG",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "XPDR1-NETWORK1",
- "dest-node": "XPDR-A1-XPDR1"
- }
- },
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "SRG1-PP4-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-PP1-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-PP2-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-PP3-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-CP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-CP"
+ }
+ ],
+ "org-openroadm-network-topology:srg-attributes": {
+ "avail-freq-maps": [
+ {
+ "map-name": "cband",
+ "freq-map-granularity": 6.25,
+ "start-edge-freq": 191.325,
+ "effective-bits": 768,
+ "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+ }
+ ]
+ },
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "ROADM-C1"
+ }
+ ]
+ },
{
- "link-id": "ROADM-A1-SRG1-SRG1-PP4-TXRXtoXPDR-A2-XPDR1-XPDR1-NETWORK1",
- "source": {
- "source-node": "ROADM-A1-SRG1",
- "source-tp": "SRG1-PP4-TXRX"
+ "node-id": "ROADM-A1-SRG1",
+ "org-openroadm-common-network:node-type": "SRG",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "SRG1-PP4-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-PP1-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-PP2-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-PP3-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
+ },
+ {
+ "tp-id": "SRG1-CP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "SRG-TXRX-CP"
+ }
+ ],
+ "org-openroadm-network-topology:srg-attributes": {
+ "avail-freq-maps": [
+ {
+ "map-name": "cband",
+ "freq-map-granularity": 6.25,
+ "start-edge-freq": 191.325,
+ "effective-bits": 768,
+ "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+ }
+ ]
},
- "org-openroadm-common-network:link-type": "XPONDER-INPUT",
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "ROADM-A1"
+ }
+ ]
+ },
+ {
+ "node-id": "ROADM-A1-DEG1",
+ "org-openroadm-common-network:node-type": "DEGREE",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "XPDR-A2-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP4-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "XPDR1-NETWORK1",
- "dest-node": "XPDR-A2-XPDR1"
- }
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "DEG1-CTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
+ },
+ {
+ "tp-id": "DEG1-TTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
+ }
+ ],
+ "org-openroadm-network-topology:degree-attributes": {
+ "degree-number": 1,
+ "avail-freq-maps": [
+ {
+ "map-name": "cband",
+ "freq-map-granularity": 6.25,
+ "start-edge-freq": 191.325,
+ "effective-bits": 768,
+ "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+ }
+ ]
+ },
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "ROADM-A1"
+ }
+ ]
},
{
- "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX",
- "source": {
- "source-node": "ROADM-C1-DEG1",
- "source-tp": "DEG1-TTP-TXRX"
+ "node-id": "ROADM-A1-DEG2",
+ "org-openroadm-common-network:node-type": "DEGREE",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "DEG2-TTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
+ },
+ {
+ "tp-id": "DEG2-CTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
+ }
+ ],
+ "org-openroadm-network-topology:degree-attributes": {
+ "degree-number": 2,
+ "avail-freq-maps": [
+ {
+ "map-name": "cband",
+ "freq-map-granularity": 6.25,
+ "start-edge-freq": 191.325,
+ "effective-bits": 768,
+ "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+ }
+ ]
},
- "org-openroadm-common-network:link-type": "ROADM-TO-ROADM",
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeA"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "ROADM-A1"
+ }
+ ]
+ },
+ {
+ "node-id": "ROADM-C1-DEG1",
+ "org-openroadm-common-network:node-type": "DEGREE",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "DEG2-TTP-TXRX",
- "dest-node": "ROADM-A1-DEG2"
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "DEG1-CTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
+ },
+ {
+ "tp-id": "DEG1-TTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
+ }
+ ],
+ "org-openroadm-network-topology:degree-attributes": {
+ "degree-number": 1,
+ "avail-freq-maps": [
+ {
+ "map-name": "cband",
+ "freq-map-granularity": 6.25,
+ "start-edge-freq": 191.325,
+ "effective-bits": 768,
+ "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+ }
+ ]
},
- "org-openroadm-network-topology:OMS-attributes": {
- "span": {
- "auto-spanloss": true,
- "spanloss-current": 12,
- "engineered-spanloss": 12.2,
- "spanloss-base": 11.4,
- "link-concatenation": [
- {
- "SRLG-Id": 0,
- "fiber-type": "smf",
- "pmd": 0.5,
- "SRLG-length": 100000
- }
- ]
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "ROADM-C1"
}
- }
+ ]
},
{
- "link-id": "ROADM-C1-SRG1-SRG1-PP4-TXRXtoXPDR-C2-XPDR1-XPDR1-NETWORK1",
+ "node-id": "ROADM-C1-DEG2",
+ "org-openroadm-common-network:node-type": "DEGREE",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "ietf-network-topology:termination-point": [
+ {
+ "tp-id": "DEG2-TTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
+ },
+ {
+ "tp-id": "DEG2-CTP-TXRX",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
+ }
+ ],
+ "org-openroadm-network-topology:degree-attributes": {
+ "degree-number": 2,
+ "avail-freq-maps": [
+ {
+ "map-name": "cband",
+ "freq-map-granularity": 6.25,
+ "start-edge-freq": 191.325,
+ "effective-bits": 768,
+ "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
+ }
+ ]
+ },
+ "supporting-node": [
+ {
+ "network-ref": "clli-network",
+ "node-ref": "NodeC"
+ },
+ {
+ "network-ref": "openroadm-network",
+ "node-ref": "ROADM-C1"
+ }
+ ]
+ }
+ ],
+ "ietf-network-topology:link": [
+ {
+ "link-id": "ROADM-A1-SRG1-SRG1-PP2-TXRXtoXPDR-A2-XPDR2-XPDR2-NETWORK1",
"source": {
- "source-node": "ROADM-C1-SRG1",
- "source-tp": "SRG1-PP4-TXRX"
+ "source-node": "ROADM-A1-SRG1",
+ "source-tp": "SRG1-PP2-TXRX"
},
"org-openroadm-common-network:link-type": "XPONDER-INPUT",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "XPDR-C2-XPDR1-XPDR1-NETWORK1toROADM-C1-SRG1-SRG1-PP4-TXRX",
+ "org-openroadm-common-network:opposite-link": "XPDR-A2-XPDR2-XPDR2-NETWORK1toROADM-A1-SRG1-SRG1-PP2-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "XPDR1-NETWORK1",
- "dest-node": "XPDR-C2-XPDR1"
+ "dest-tp": "XPDR2-NETWORK1",
+ "dest-node": "XPDR-A2-XPDR2"
}
},
{
- "link-id": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
+ "link-id": "ROADM-C1-SRG1-SRG1-PP2-TXRXtoXPDR-C2-XPDR2-XPDR2-NETWORK1",
"source": {
- "source-node": "ROADM-C1-DEG2",
- "source-tp": "DEG2-CTP-TXRX"
+ "source-node": "ROADM-C1-SRG1",
+ "source-tp": "SRG1-PP2-TXRX"
},
- "org-openroadm-common-network:link-type": "EXPRESS-LINK",
+ "org-openroadm-common-network:link-type": "XPONDER-INPUT",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
+ "org-openroadm-common-network:opposite-link": "XPDR-C2-XPDR2-XPDR2-NETWORK1toROADM-C1-SRG1-SRG1-PP2-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "DEG1-CTP-TXRX",
- "dest-node": "ROADM-C1-DEG1"
+ "dest-tp": "XPDR2-NETWORK1",
+ "dest-node": "XPDR-C2-XPDR2"
}
},
{
- "link-id": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
+ "link-id": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX",
"source": {
- "source-node": "ROADM-C1-DEG2",
- "source-tp": "DEG2-CTP-TXRX"
+ "source-node": "ROADM-A1-DEG2",
+ "source-tp": "DEG2-TTP-TXRX"
},
- "org-openroadm-common-network:link-type": "DROP-LINK",
+ "org-openroadm-common-network:link-type": "ROADM-TO-ROADM",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "SRG1-CP-TXRX",
- "dest-node": "ROADM-C1-SRG1"
+ "dest-tp": "DEG1-TTP-TXRX",
+ "dest-node": "ROADM-C1-DEG1"
+ },
+ "org-openroadm-network-topology:OMS-attributes": {
+ "span": {
+ "auto-spanloss": true,
+ "spanloss-current": 12,
+ "engineered-spanloss": 12.2,
+ "spanloss-base": 11.4,
+ "link-concatenation": [
+ {
+ "SRLG-Id": 0,
+ "fiber-type": "smf",
+ "pmd": 0.5,
+ "SRLG-length": 100000
+ }
+ ]
+ }
}
},
{
- "link-id": "XPDR-A2-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP4-TXRX",
+ "link-id": "XPDR-A2-XPDR2-XPDR2-NETWORK1toROADM-A1-SRG1-SRG1-PP2-TXRX",
"source": {
- "source-node": "XPDR-A2-XPDR1",
- "source-tp": "XPDR1-NETWORK1"
+ "source-node": "XPDR-A2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
},
"org-openroadm-common-network:link-type": "XPONDER-OUTPUT",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-PP4-TXRXtoXPDR-A2-XPDR1-XPDR1-NETWORK1",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-PP2-TXRXtoXPDR-A2-XPDR2-XPDR2-NETWORK1",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "SRG1-PP4-TXRX",
+ "dest-tp": "SRG1-PP2-TXRX",
"dest-node": "ROADM-A1-SRG1"
}
},
{
- "link-id": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
+ "link-id": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
"source": {
- "source-node": "ROADM-A1-DEG2",
- "source-tp": "DEG2-CTP-TXRX"
+ "source-node": "ROADM-C1-DEG1",
+ "source-tp": "DEG1-CTP-TXRX"
},
"org-openroadm-common-network:link-type": "DROP-LINK",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
"dest-tp": "SRG1-CP-TXRX",
- "dest-node": "ROADM-A1-SRG1"
+ "dest-node": "ROADM-C1-SRG1"
}
},
{
- "link-id": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
+ "link-id": "ROADM-C1-SRG1-SRG1-PP1-TXRXtoXPDR-C2-XPDR1-XPDR1-NETWORK1",
"source": {
- "source-node": "ROADM-C1-DEG1",
- "source-tp": "DEG1-CTP-TXRX"
+ "source-node": "ROADM-C1-SRG1",
+ "source-tp": "SRG1-PP1-TXRX"
},
- "org-openroadm-common-network:link-type": "EXPRESS-LINK",
+ "org-openroadm-common-network:link-type": "XPONDER-INPUT",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
+ "org-openroadm-common-network:opposite-link": "XPDR-C2-XPDR1-XPDR1-NETWORK1toROADM-C1-SRG1-SRG1-PP1-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "DEG2-CTP-TXRX",
- "dest-node": "ROADM-C1-DEG2"
+ "dest-tp": "XPDR1-NETWORK1",
+ "dest-node": "XPDR-C2-XPDR1"
}
},
{
- "link-id": "XPDR-A1-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX",
+ "link-id": "XPDR-A2-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX",
"source": {
- "source-node": "XPDR-A1-XPDR1",
+ "source-node": "XPDR-A2-XPDR1",
"source-tp": "XPDR1-NETWORK1"
},
"org-openroadm-common-network:link-type": "XPONDER-OUTPUT",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A1-XPDR1-XPDR1-NETWORK1",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A2-XPDR1-XPDR1-NETWORK1",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
"dest-tp": "SRG1-PP1-TXRX",
}
},
{
- "link-id": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
- "source": {
- "source-node": "ROADM-A1-DEG2",
- "source-tp": "DEG2-CTP-TXRX"
- },
- "org-openroadm-common-network:link-type": "EXPRESS-LINK",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
- "org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "DEG1-CTP-TXRX",
- "dest-node": "ROADM-A1-DEG1"
- }
- },
- {
- "link-id": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
+ "link-id": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
"source": {
- "source-node": "ROADM-A1-SRG1",
- "source-tp": "SRG1-CP-TXRX"
+ "source-node": "ROADM-A1-SRG3",
+ "source-tp": "SRG3-CP-TXRX"
},
"org-openroadm-common-network:link-type": "ADD-LINK",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
"dest-tp": "DEG1-CTP-TXRX",
}
},
{
- "link-id": "ROADM-C1-SRG1-SRG1-PP1-TXRXtoXPDR-C1-XPDR1-XPDR1-NETWORK1",
+ "link-id": "ROADM-A1-SRG1-SRG1-PP1-TXRXtoXPDR-A2-XPDR1-XPDR1-NETWORK1",
"source": {
- "source-node": "ROADM-C1-SRG1",
+ "source-node": "ROADM-A1-SRG1",
"source-tp": "SRG1-PP1-TXRX"
},
"org-openroadm-common-network:link-type": "XPONDER-INPUT",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "XPDR-C1-XPDR1-XPDR1-NETWORK1toROADM-C1-SRG1-SRG1-PP1-TXRX",
+ "org-openroadm-common-network:opposite-link": "XPDR-A2-XPDR1-XPDR1-NETWORK1toROADM-A1-SRG1-SRG1-PP1-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
"dest-tp": "XPDR1-NETWORK1",
- "dest-node": "XPDR-C1-XPDR1"
- }
- },
- {
- "link-id": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
- "source": {
- "source-node": "ROADM-A1-DEG2",
- "source-tp": "DEG2-CTP-TXRX"
- },
- "org-openroadm-common-network:link-type": "DROP-LINK",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
- "org-openroadm-common-network:administrative-state": "inService",
- "destination": {
- "dest-tp": "SRG3-CP-TXRX",
- "dest-node": "ROADM-A1-SRG3"
+ "dest-node": "XPDR-A2-XPDR1"
}
},
{
- "link-id": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
+ "link-id": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
"source": {
- "source-node": "ROADM-A1-SRG1",
- "source-tp": "SRG1-CP-TXRX"
+ "source-node": "ROADM-A1-SRG3",
+ "source-tp": "SRG3-CP-TXRX"
},
"org-openroadm-common-network:link-type": "ADD-LINK",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
"dest-tp": "DEG2-CTP-TXRX",
}
},
{
- "link-id": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
+ "link-id": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
"source": {
- "source-node": "ROADM-C1-SRG1",
- "source-tp": "SRG1-CP-TXRX"
+ "source-node": "ROADM-A1-DEG1",
+ "source-tp": "DEG1-CTP-TXRX"
},
- "org-openroadm-common-network:link-type": "ADD-LINK",
+ "org-openroadm-common-network:link-type": "DROP-LINK",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "DEG2-CTP-TXRX",
- "dest-node": "ROADM-C1-DEG2"
+ "dest-tp": "SRG3-CP-TXRX",
+ "dest-node": "ROADM-A1-SRG3"
}
},
{
- "link-id": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
+ "link-id": "ROADM-C1-DEG1-DEG1-TTP-TXRXtoROADM-A1-DEG2-DEG2-TTP-TXRX",
"source": {
- "source-node": "ROADM-A1-DEG1",
- "source-tp": "DEG1-CTP-TXRX"
+ "source-node": "ROADM-C1-DEG1",
+ "source-tp": "DEG1-TTP-TXRX"
},
- "org-openroadm-common-network:link-type": "DROP-LINK",
+ "org-openroadm-common-network:link-type": "ROADM-TO-ROADM",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-TTP-TXRXtoROADM-C1-DEG1-DEG1-TTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "SRG1-CP-TXRX",
- "dest-node": "ROADM-A1-SRG1"
+ "dest-tp": "DEG2-TTP-TXRX",
+ "dest-node": "ROADM-A1-DEG2"
+ },
+ "org-openroadm-network-topology:OMS-attributes": {
+ "span": {
+ "auto-spanloss": true,
+ "spanloss-current": 12,
+ "engineered-spanloss": 12.2,
+ "spanloss-base": 11.4,
+ "link-concatenation": [
+ {
+ "SRLG-Id": 0,
+ "fiber-type": "smf",
+ "pmd": 0.5,
+ "SRLG-length": 100000
+ }
+ ]
+ }
}
},
{
- "link-id": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
+ "link-id": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
"source": {
- "source-node": "ROADM-C1-SRG1",
- "source-tp": "SRG1-CP-TXRX"
+ "source-node": "ROADM-C1-DEG2",
+ "source-tp": "DEG2-CTP-TXRX"
},
- "org-openroadm-common-network:link-type": "ADD-LINK",
+ "org-openroadm-common-network:link-type": "EXPRESS-LINK",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
"dest-tp": "DEG1-CTP-TXRX",
}
},
{
- "link-id": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
+ "link-id": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
"source": {
- "source-node": "ROADM-A1-DEG1",
- "source-tp": "DEG1-CTP-TXRX"
+ "source-node": "ROADM-C1-DEG2",
+ "source-tp": "DEG2-CTP-TXRX"
},
- "org-openroadm-common-network:link-type": "EXPRESS-LINK",
+ "org-openroadm-common-network:link-type": "DROP-LINK",
"org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
"destination": {
- "dest-tp": "DEG2-CTP-TXRX",
- "dest-node": "ROADM-A1-DEG2"
+ "dest-tp": "SRG1-CP-TXRX",
+ "dest-node": "ROADM-C1-SRG1"
}
- }
- ],
- "network-types": {
- "org-openroadm-common-network:openroadm-common-network": {}
- },
- "node": [
+ },
{
- "node-id": "ROADM-A1-SRG3",
- "org-openroadm-common-network:node-type": "SRG",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-network-topology:srg-attributes": {
- "avail-freq-maps": [
- {
- "map-name": "cband",
- "freq-map-granularity": 6.25,
- "start-edge-freq": 191.325,
- "effective-bits": 768,
- "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
- }
- ]
- },
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "SRG3-PP3-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG3-PP2-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG3-CP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-CP"
- },
- {
- "tp-id": "SRG3-PP1-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG3-PP4-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeA"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "ROADM-A1"
- }
- ]
+ "link-id": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
+ "source": {
+ "source-node": "ROADM-A1-DEG2",
+ "source-tp": "DEG2-CTP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "DROP-LINK",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "destination": {
+ "dest-tp": "SRG1-CP-TXRX",
+ "dest-node": "ROADM-A1-SRG1"
+ }
},
{
- "node-id": "XPDR-A2-XPDR1",
- "org-openroadm-common-network:node-type": "XPONDER",
+ "link-id": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
+ "source": {
+ "source-node": "ROADM-C1-DEG1",
+ "source-tp": "DEG1-CTP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "EXPRESS-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "XPDR1-CLIENT1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
- },
- {
- "tp-id": "XPDR1-NETWORK1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
- "org-openroadm-network-topology:xpdr-network-attributes": {
- "tail-equipment-id": "ROADM-A1-SRG1--SRG1-PP4-TXRX"
- },
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeA"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "XPDR-A2"
- }
- ]
+ "destination": {
+ "dest-tp": "DEG2-CTP-TXRX",
+ "dest-node": "ROADM-C1-DEG2"
+ }
},
{
- "node-id": "XPDR-C2-XPDR1",
- "org-openroadm-common-network:node-type": "XPONDER",
+ "link-id": "XPDR-C2-XPDR2-XPDR2-NETWORK1toROADM-C1-SRG1-SRG1-PP2-TXRX",
+ "source": {
+ "source-node": "XPDR-C2-XPDR2",
+ "source-tp": "XPDR2-NETWORK1"
+ },
+ "org-openroadm-common-network:link-type": "XPONDER-OUTPUT",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-PP2-TXRXtoXPDR-C2-XPDR2-XPDR2-NETWORK1",
"org-openroadm-common-network:administrative-state": "inService",
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "XPDR1-CLIENT1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
- },
- {
- "tp-id": "XPDR1-NETWORK1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
- "org-openroadm-network-topology:xpdr-network-attributes": {
- "tail-equipment-id": "ROADM-C1-SRG1--SRG1-PP4-TXRX"
- },
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "openroadm-network",
- "node-ref": "XPDR-C2"
- },
- {
- "network-ref": "clli-network",
- "node-ref": "NodeC"
- }
- ]
+ "destination": {
+ "dest-tp": "SRG1-PP2-TXRX",
+ "dest-node": "ROADM-C1-SRG1"
+ }
},
{
- "node-id": "XPDR-C1-XPDR1",
- "org-openroadm-common-network:node-type": "XPONDER",
+ "link-id": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
+ "source": {
+ "source-node": "ROADM-A1-DEG2",
+ "source-tp": "DEG2-CTP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "EXPRESS-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "XPDR1-CLIENT1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
- },
- {
- "tp-id": "XPDR1-CLIENT2",
- "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK2",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
- },
- {
- "tp-id": "XPDR1-NETWORK2",
- "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT2",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
- },
- {
- "tp-id": "XPDR1-NETWORK1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
- "org-openroadm-network-topology:xpdr-network-attributes": {
- "tail-equipment-id": "ROADM-C1-SRG1--SRG1-PP1-TXRX"
- },
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeC"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "XPDR-C1"
- }
- ]
+ "destination": {
+ "dest-tp": "DEG1-CTP-TXRX",
+ "dest-node": "ROADM-A1-DEG1"
+ }
},
{
- "node-id": "ROADM-C1-SRG1",
- "org-openroadm-common-network:node-type": "SRG",
+ "link-id": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
+ "source": {
+ "source-node": "ROADM-A1-SRG1",
+ "source-tp": "SRG1-CP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "ADD-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-network-topology:srg-attributes": {
- "avail-freq-maps": [
- {
- "map-name": "cband",
- "freq-map-granularity": 6.25,
- "start-edge-freq": 191.325,
- "effective-bits": 768,
- "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
- }
- ]
- },
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "SRG1-PP4-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-PP1-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-PP2-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-PP3-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-CP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-CP"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeC"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "ROADM-C1"
- }
- ]
+ "destination": {
+ "dest-tp": "DEG1-CTP-TXRX",
+ "dest-node": "ROADM-A1-DEG1"
+ }
},
{
- "node-id": "ROADM-A1-SRG1",
- "org-openroadm-common-network:node-type": "SRG",
+ "link-id": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG3-SRG3-CP-TXRX",
+ "source": {
+ "source-node": "ROADM-A1-DEG2",
+ "source-tp": "DEG2-CTP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "DROP-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG3-SRG3-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-network-topology:srg-attributes": {
- "avail-freq-maps": [
- {
- "map-name": "cband",
- "freq-map-granularity": 6.25,
- "start-edge-freq": 191.325,
- "effective-bits": 768,
- "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
- }
- ]
- },
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "SRG1-PP4-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-PP1-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-PP2-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-PP3-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-PP"
- },
- {
- "tp-id": "SRG1-CP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "SRG-TXRX-CP"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeA"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "ROADM-A1"
- }
- ]
+ "destination": {
+ "dest-tp": "SRG3-CP-TXRX",
+ "dest-node": "ROADM-A1-SRG3"
+ }
},
{
- "node-id": "ROADM-A1-DEG1",
- "org-openroadm-common-network:node-type": "DEGREE",
+ "link-id": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
+ "source": {
+ "source-node": "ROADM-A1-SRG1",
+ "source-tp": "SRG1-CP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "ADD-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-network-topology:degree-attributes": {
- "degree-number": 1,
- "avail-freq-maps": [
- {
- "map-name": "cband",
- "freq-map-granularity": 6.25,
- "start-edge-freq": 191.325,
- "effective-bits": 768,
- "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
- }
- ]
- },
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "DEG1-CTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
- },
- {
- "tp-id": "DEG1-TTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeA"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "ROADM-A1"
- }
- ]
+ "destination": {
+ "dest-tp": "DEG2-CTP-TXRX",
+ "dest-node": "ROADM-A1-DEG2"
+ }
},
{
- "node-id": "ROADM-A1-DEG2",
- "org-openroadm-common-network:node-type": "DEGREE",
+ "link-id": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG2-DEG2-CTP-TXRX",
+ "source": {
+ "source-node": "ROADM-C1-SRG1",
+ "source-tp": "SRG1-CP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "ADD-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG2-DEG2-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-network-topology:degree-attributes": {
- "degree-number": 2,
- "avail-freq-maps": [
- {
- "map-name": "cband",
- "freq-map-granularity": 6.25,
- "start-edge-freq": 191.325,
- "effective-bits": 768,
- "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
- }
- ]
- },
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "DEG2-TTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
- },
- {
- "tp-id": "DEG2-CTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeA"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "ROADM-A1"
- }
- ]
+ "destination": {
+ "dest-tp": "DEG2-CTP-TXRX",
+ "dest-node": "ROADM-C1-DEG2"
+ }
},
{
- "node-id": "XPDR-A1-XPDR1",
- "org-openroadm-common-network:node-type": "XPONDER",
+ "link-id": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-SRG1-SRG1-CP-TXRX",
+ "source": {
+ "source-node": "ROADM-A1-DEG1",
+ "source-tp": "DEG1-CTP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "DROP-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-SRG1-SRG1-CP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "XPDR1-CLIENT1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK1",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
- },
- {
- "tp-id": "XPDR1-CLIENT2",
- "transportpce-topology:associated-connection-map-port": "XPDR1-NETWORK2",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-CLIENT"
- },
- {
- "tp-id": "XPDR1-NETWORK2",
- "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT2",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
- },
- {
- "tp-id": "XPDR1-NETWORK1",
- "transportpce-topology:associated-connection-map-port": "XPDR1-CLIENT1",
- "org-openroadm-network-topology:xpdr-network-attributes": {
- "tail-equipment-id": "ROADM-A1-SRG1--SRG1-PP1-TXRX"
- },
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "XPONDER-NETWORK"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "openroadm-network",
- "node-ref": "XPDR-A1"
- },
- {
- "network-ref": "clli-network",
- "node-ref": "NodeA"
- }
- ]
+ "destination": {
+ "dest-tp": "SRG1-CP-TXRX",
+ "dest-node": "ROADM-A1-SRG1"
+ }
},
{
- "node-id": "ROADM-C1-DEG1",
- "org-openroadm-common-network:node-type": "DEGREE",
+ "link-id": "ROADM-C1-SRG1-SRG1-CP-TXRXtoROADM-C1-DEG1-DEG1-CTP-TXRX",
+ "source": {
+ "source-node": "ROADM-C1-SRG1",
+ "source-tp": "SRG1-CP-TXRX"
+ },
+ "org-openroadm-common-network:link-type": "ADD-LINK",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-DEG1-DEG1-CTP-TXRXtoROADM-C1-SRG1-SRG1-CP-TXRX",
"org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-network-topology:degree-attributes": {
- "degree-number": 1,
- "avail-freq-maps": [
- {
- "map-name": "cband",
- "freq-map-granularity": 6.25,
- "start-edge-freq": 191.325,
- "effective-bits": 768,
- "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
- }
- ]
- },
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "DEG1-CTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
- },
- {
- "tp-id": "DEG1-TTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeC"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "ROADM-C1"
- }
- ]
+ "destination": {
+ "dest-tp": "DEG1-CTP-TXRX",
+ "dest-node": "ROADM-C1-DEG1"
+ }
},
{
- "node-id": "ROADM-C1-DEG2",
- "org-openroadm-common-network:node-type": "DEGREE",
+ "link-id": "XPDR-C2-XPDR1-XPDR1-NETWORK1toROADM-C1-SRG1-SRG1-PP1-TXRX",
+ "source": {
+ "source-node": "XPDR-C2-XPDR1",
+ "source-tp": "XPDR1-NETWORK1"
+ },
+ "org-openroadm-common-network:link-type": "XPONDER-OUTPUT",
"org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-C1-SRG1-SRG1-PP1-TXRXtoXPDR-C2-XPDR1-XPDR1-NETWORK1",
"org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-network-topology:degree-attributes": {
- "degree-number": 2,
- "avail-freq-maps": [
- {
- "map-name": "cband",
- "freq-map-granularity": 6.25,
- "start-edge-freq": 191.325,
- "effective-bits": 768,
- "freq-map": "////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////"
- }
- ]
+ "destination": {
+ "dest-tp": "SRG1-PP1-TXRX",
+ "dest-node": "ROADM-C1-SRG1"
+ }
+ },
+ {
+ "link-id": "ROADM-A1-DEG1-DEG1-CTP-TXRXtoROADM-A1-DEG2-DEG2-CTP-TXRX",
+ "source": {
+ "source-node": "ROADM-A1-DEG1",
+ "source-tp": "DEG1-CTP-TXRX"
},
- "ietf-network-topology:termination-point": [
- {
- "tp-id": "DEG2-TTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-TTP"
- },
- {
- "tp-id": "DEG2-CTP-TXRX",
- "org-openroadm-common-network:operational-state": "inService",
- "org-openroadm-common-network:administrative-state": "inService",
- "org-openroadm-common-network:tp-type": "DEGREE-TXRX-CTP"
- }
- ],
- "supporting-node": [
- {
- "network-ref": "clli-network",
- "node-ref": "NodeC"
- },
- {
- "network-ref": "openroadm-network",
- "node-ref": "ROADM-C1"
- }
- ]
+ "org-openroadm-common-network:link-type": "EXPRESS-LINK",
+ "org-openroadm-common-network:operational-state": "inService",
+ "org-openroadm-common-network:opposite-link": "ROADM-A1-DEG2-DEG2-CTP-TXRXtoROADM-A1-DEG1-DEG1-CTP-TXRX",
+ "org-openroadm-common-network:administrative-state": "inService",
+ "destination": {
+ "dest-tp": "DEG2-CTP-TXRX",
+ "dest-node": "ROADM-A1-DEG2"
+ }
}
]
}
<?xml version="1.0" encoding="UTF-8"?>
<data xmlns="urn:ietf:params:xml:ns:netconf:base:1.0">
<netconf xmlns="urn:ietf:params:xml:ns:netmod:notification">
- <streams>
- <stream>
- <name>OPENROADM</name>
- </stream>
- </streams>
-</netconf>
+ <streams>
+ <stream>
+ <name>OPENROADM</name>
+ </stream>
+ </streams>
+ </netconf>
<org-openroadm-device xmlns="http://org/openroadm/device">
<info>
<node-id>XPDR-A2</node-id>
<slot-name>slot-2</slot-name>
<label>2</label>
<provisioned-circuit-pack>1/0/1-PLUG-CLIENT</provisioned-circuit-pack>
+ <slot-status>installed-prov-match</slot-status>
</cp-slots>
<cp-slots>
<slot-name>slot-3</slot-name>
<label>3</label>
- <slot-status>empty-not-prov</slot-status>
+ <provisioned-circuit-pack>1/0/3-PLUG-CLIENT</provisioned-circuit-pack>
+ <slot-status>installed-prov-match</slot-status>
</cp-slots>
<cp-slots>
<slot-name>slot-4</slot-name>
<label>4</label>
<slot-status>empty-not-prov</slot-status>
</cp-slots>
+ <cp-slots>
+ <slot-name>slot-5</slot-name>
+ <label>5</label>
+ <slot-status>empty-not-prov</slot-status>
+ </cp-slots>
+ <cp-slots>
+ <slot-name>slot-6</slot-name>
+ <label>6</label>
+ <slot-status>empty-not-prov</slot-status>
+ </cp-slots>
+ <cp-slots>
+ <slot-name>slot-7</slot-name>
+ <label>7</label>
+ <provisioned-circuit-pack>1/0/7-PLUG-NET</provisioned-circuit-pack>
+ <slot-status>installed-prov-match</slot-status>
+ </cp-slots>
</circuit-packs>
<circuit-packs>
<circuit-pack-name>1/0/1-PLUG-NET</circuit-pack-name>
<port-capabilities xmlns="http://org/openroadm/port-capability">
<supported-interface-capability>
<if-cap-type xmlns:org-openroadm-port-types="http://org/openroadm/port/types">org-openroadm-port-types:if-otsi-otsigroup</if-cap-type>
- <otsigroup-capability-profile-name>otsigroup-profile1</otsigroup-capability-profile-name>
+ <otsigroup-capability-profile-name>FOIC4.8-OTUC4</otsigroup-capability-profile-name>
+ <otsigroup-capability-profile-name>FOIC3.6-OTUC3</otsigroup-capability-profile-name>
+ <otsigroup-capability-profile-name>FOIC2.4-OTUC2</otsigroup-capability-profile-name>
</supported-interface-capability>
</port-capabilities>
</ports>
<lifecycle-state>deployed</lifecycle-state>
<administrative-state>inService</administrative-state>
<operational-state>inService</operational-state>
- <transponder-port>
- <port-power-capability-min-rx>-22.00</port-power-capability-min-rx>
- <port-power-capability-min-tx>-5.00</port-power-capability-min-tx>
- <port-power-capability-max-rx>1.00</port-power-capability-max-rx>
- <port-power-capability-max-tx>0.00</port-power-capability-max-tx>
- </transponder-port>
<port-capabilities xmlns="http://org/openroadm/port-capability">
<supported-interface-capability>
<if-cap-type xmlns:org-openroadm-port-types="http://org/openroadm/port/types">org-openroadm-port-types:if-400GE</if-cap-type>
</port-capabilities>
</ports>
</circuit-packs>
+ <circuit-packs>
+ <circuit-pack-name>1/0/3-PLUG-CLIENT</circuit-pack-name>
+ <circuit-pack-type>client_pluggable</circuit-pack-type>
+ <circuit-pack-product-code>Client_P</circuit-pack-product-code>
+ <lifecycle-state>deployed</lifecycle-state>
+ <administrative-state>inService</administrative-state>
+ <vendor>VendorA</vendor>
+ <model>QSFP28</model>
+ <serial-id>serial-1234</serial-id>
+ <type>client_pluggable</type>
+ <product-code>clientXPDR</product-code>
+ <manufacture-date>2007-10-10T00:00:00Z</manufacture-date>
+ <clei>12345678901</clei>
+ <hardware-version>0.1</hardware-version>
+ <operational-state>inService</operational-state>
+ <circuit-pack-category>
+ <type>circuitPack</type>
+ </circuit-pack-category>
+ <equipment-state>not-reserved-available</equipment-state>
+ <circuit-pack-mode>NORMAL</circuit-pack-mode>
+ <shelf>1</shelf>
+ <slot>1</slot>
+ <subSlot>3</subSlot>
+ <is-pluggable-optics>true</is-pluggable-optics>
+ <is-physical>true</is-physical>
+ <is-passive>true</is-passive>
+ <faceplate-label>xponder-XPDRA</faceplate-label>
+ <parent-circuit-pack>
+ <circuit-pack-name>1/0</circuit-pack-name>
+ <cp-slot-name>slot-3</cp-slot-name>
+ </parent-circuit-pack>
+ <ports>
+ <port-name>C3</port-name>
+ <administrative-state>inService</administrative-state>
+ <operational-state>inService</operational-state>
+ <port-capabilities xmlns="http://org/openroadm/port-capability">
+ <supported-interface-capability>
+ <if-cap-type xmlns:x="http://org/openroadm/port/types">x:if-100GE-ODU4</if-cap-type>
+ <otn-capability>
+ <mpdr-client-restriction>
+ <network-ho-odu-circuit-pack-name>1/0/7-PLUG-NETWORK</network-ho-odu-circuit-pack-name>
+ <muxp-profile-name>ABCD-4-BY-100G-1</muxp-profile-name>
+ <muxp-profile-name>ABCD-3-BY-100G-1</muxp-profile-name>
+ <network-ho-odu-port-name>1</network-ho-odu-port-name>
+ </mpdr-client-restriction>
+ </otn-capability>
+ </supported-interface-capability>
+ <supported-interface-capability>
+ <if-cap-type xmlns:x="http://org/openroadm/port/types">x:if-OCH-OTU4-ODU4</if-cap-type>
+ <otn-capability>
+ <mpdr-client-restriction>
+ <network-ho-odu-circuit-pack-name>1/0/7-PLUG-NETWORK</network-ho-odu-circuit-pack-name>
+ <muxp-profile-name>ABCD-4-BY-100G-1</muxp-profile-name>
+ <muxp-profile-name>ABCD-3-BY-100G-1</muxp-profile-name>
+ <network-ho-odu-port-name>1</network-ho-odu-port-name>
+ </mpdr-client-restriction>
+ </otn-capability>
+ </supported-interface-capability>
+ </port-capabilities>
+ <port-type>QSFP28</port-type>
+ <port-direction>bidirectional</port-direction>
+ <port-wavelength-type>wavelength</port-wavelength-type>
+ <port-qual>switch-client</port-qual>
+ </ports>
+ </circuit-packs>
+ <circuit-packs>
+ <circuit-pack-name>1/0/7-PLUG-NETWORK</circuit-pack-name>
+ <circuit-pack-type>CFP2-DCO</circuit-pack-type>
+ <circuit-pack-product-code>Line_NW_P</circuit-pack-product-code>
+ <lifecycle-state>deployed</lifecycle-state>
+ <administrative-state>inService</administrative-state>
+ <vendor>VendorA</vendor>
+ <model>CFP2-DCO</model>
+ <serial-id>serial-1234</serial-id>
+ <type>line_pluggable</type>
+ <product-code>lineXPDR</product-code>
+ <manufacture-date>2007-10-10T00:00:00Z</manufacture-date>
+ <clei>12345678901</clei>
+ <hardware-version>0.1</hardware-version>
+ <operational-state>inService</operational-state>
+ <circuit-pack-category>
+ <type>circuitPack</type>
+ </circuit-pack-category>
+ <equipment-state>not-reserved-available</equipment-state>
+ <circuit-pack-mode>NORMAL</circuit-pack-mode>
+ <shelf>1</shelf>
+ <slot>1</slot>
+ <subSlot>7</subSlot>
+ <is-pluggable-optics>true</is-pluggable-optics>
+ <is-physical>true</is-physical>
+ <is-passive>true</is-passive>
+ <faceplate-label>xponder-XPDRA</faceplate-label>
+ <parent-circuit-pack>
+ <circuit-pack-name>1/0</circuit-pack-name>
+ <cp-slot-name>slot-7</cp-slot-name>
+ </parent-circuit-pack>
+ <ports>
+ <port-name>L2</port-name>
+ <administrative-state>inService</administrative-state>
+ <port-capabilities xmlns="http://org/openroadm/port-capability">
+ <supported-interface-capability>
+ <if-cap-type xmlns:x="http://org/openroadm/port/types">x:if-otsi-otsigroup</if-cap-type>
+ <otsigroup-capability-profile-name>FOIC4.8-OTUC4</otsigroup-capability-profile-name>
+ <otsigroup-capability-profile-name>FOIC3.6-OTUC3</otsigroup-capability-profile-name>
+ <otsigroup-capability-profile-name>FOIC2.4-OTUC2</otsigroup-capability-profile-name>
+ </supported-interface-capability>
+ </port-capabilities>
+ <port-type>CFP2-DCO</port-type>
+ <faceplate-label>pluggable</faceplate-label>
+ <is-physical>true</is-physical>
+ <operational-state>inService</operational-state>
+ <transponder-port>
+ <port-power-capability-max-rx>13.0</port-power-capability-max-rx>
+ <port-power-capability-min-tx>-5.0</port-power-capability-min-tx>
+ <port-power-capability-min-rx>-22.0</port-power-capability-min-rx>
+ <port-power-capability-max-tx>0.0</port-power-capability-max-tx>
+ </transponder-port>
+ <port-direction>bidirectional</port-direction>
+ <port-wavelength-type>wavelength</port-wavelength-type>
+ <port-qual>switch-network</port-qual>
+ </ports>
+ </circuit-packs>
+ <otsigroup-capability-profile>
+ <profile-name>FOIC2.4-OTUC2</profile-name>
+ <foic-type xmlns:x="http://org/openroadm/common-optical-channel-types">x:foic2.4</foic-type>
+ <otn-odu-mux-hierarchy-profile-name>one-stage-ODUCn-ODU4</otn-odu-mux-hierarchy-profile-name>
+ <if-cap-type xmlns:x="http://org/openroadm/port/types">x:if-OTUCn-ODUCn</if-cap-type>
+ <otucn-n-rate>2</otucn-n-rate>
+ </otsigroup-capability-profile>
+ <otsigroup-capability-profile>
+ <profile-name>FOIC3.6-OTUC3</profile-name>
+ <foic-type xmlns:x="http://org/openroadm/common-optical-channel-types">x:foic3.6</foic-type>
+ <otn-odu-mux-hierarchy-profile-name>one-stage-ODUCn-ODU4</otn-odu-mux-hierarchy-profile-name>
+ <if-cap-type xmlns:x="http://org/openroadm/port/types">x:if-OTUCn-ODUCn</if-cap-type>
+ <otucn-n-rate>3</otucn-n-rate>
+ </otsigroup-capability-profile>
+ <otsigroup-capability-profile>
+ <profile-name>FOIC4.8-OTUC4</profile-name>
+ <foic-type xmlns:x="http://org/openroadm/common-optical-channel-types">x:foic4.8</foic-type>
+ <otn-odu-mux-hierarchy-profile-name>one-stage-ODUCn-ODUflex-ODU4</otn-odu-mux-hierarchy-profile-name>
+ <if-cap-type xmlns:x="http://org/openroadm/port/types">x:if-OTUCn-ODUCn</if-cap-type>
+ <otucn-n-rate>4</otucn-n-rate>
+ </otsigroup-capability-profile>
+ <muxp-profile>
+ <profile-name>ABCD-4-BY-100G-1</profile-name>
+ <network-ho-odu-trib-port-number>1</network-ho-odu-trib-port-number>
+ <network-ho-odu-opucn-trib-slots>1.3</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.2</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.5</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.4</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.1</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.18</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.17</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.16</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.15</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.7</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.6</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.9</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.19</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.8</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.10</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.20</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.14</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.13</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.12</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.11</network-ho-odu-opucn-trib-slots>
+ <odtu-type xmlns:x="http://org/openroadm/otn-common-types">x:ODTUCn.ts</odtu-type>
+ </muxp-profile>
+ <muxp-profile>
+ <profile-name>ABCD-4-BY-100G-2</profile-name>
+ <network-ho-odu-trib-port-number>2</network-ho-odu-trib-port-number>
+ <network-ho-odu-opucn-trib-slots>2.2</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.1</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.4</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.3</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.9</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.16</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.6</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.17</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.5</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.18</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.8</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.19</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.7</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.12</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.13</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.14</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.15</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.20</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.10</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>2.11</network-ho-odu-opucn-trib-slots>
+ <odtu-type xmlns:x="http://org/openroadm/otn-common-types">x:ODTUCn.ts</odtu-type>
+ </muxp-profile>
+ <muxp-profile>
+ <profile-name>ABCD-4-BY-100G-3</profile-name>
+ <network-ho-odu-trib-port-number>3</network-ho-odu-trib-port-number>
+ <network-ho-odu-opucn-trib-slots>3.1</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.3</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.2</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.9</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.8</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.17</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.5</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.18</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.4</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.19</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.7</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.6</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.13</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.14</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.15</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.16</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.20</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.10</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.11</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>3.12</network-ho-odu-opucn-trib-slots>
+ <odtu-type xmlns:x="http://org/openroadm/otn-common-types">x:ODTUCn.ts</odtu-type>
+ </muxp-profile>
+ <muxp-profile>
+ <profile-name>ABCD-4-BY-100G-4</profile-name>
+ <network-ho-odu-trib-port-number>4</network-ho-odu-trib-port-number>
+ <network-ho-odu-opucn-trib-slots>4.2</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.1</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.8</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.7</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.9</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.19</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.4</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.18</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.3</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.6</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.5</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.15</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.14</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.17</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.16</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.11</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.10</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.13</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.12</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>4.20</network-ho-odu-opucn-trib-slots>
+ <odtu-type xmlns:x="http://org/openroadm/otn-common-types">x:ODTUCn.ts</odtu-type>
+ </muxp-profile>
+ <muxp-profile>
+ <profile-name>ABCD-3-BY-100G-1</profile-name>
+ <network-oducn-n-rate>3</network-oducn-n-rate>
+ <odtu-type xmlns:x="http://org/openroadm/otn-common-types">x:ODTUCn.ts</odtu-type>
+ <network-ho-odu-trib-port-number>1</network-ho-odu-trib-port-number>
+ <network-ho-odu-opucn-trib-slots>1.3</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.2</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.5</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.4</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.1</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.18</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.17</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.16</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.15</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.7</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.6</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.9</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.8</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.19</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.10</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.20</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.14</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.13</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.12</network-ho-odu-opucn-trib-slots>
+ <network-ho-odu-opucn-trib-slots>1.11</network-ho-odu-opucn-trib-slots>
+ <network-odu-rate xmlns:x="http://org/openroadm/otn-common-types">x:ODUCn</network-odu-rate>
+ </muxp-profile>
<xponder>
<xpdr-number>1</xpdr-number>
<xpdr-type>tpdr</xpdr-type>
<eqpt-srg-id>1</eqpt-srg-id>
</xpdr-port>
</xponder>
+ <xponder>
+ <xpdr-number>2</xpdr-number>
+ <xpdr-type>mpdr</xpdr-type>
+ <xpdr-port>
+ <index>1</index>
+ <circuit-pack-name>1/0/7-PLUG-NETWORK</circuit-pack-name>
+ <port-name>L2</port-name>
+ </xpdr-port>
+ <xpdr-port>
+ <index>2</index>
+ <circuit-pack-name>1/0/3-PLUG-CLIENT</circuit-pack-name>
+ <port-name>C3</port-name>
+ </xpdr-port>
+ </xponder>
<connection-map>
<connection-map-number>1</connection-map-number>
<source>
<port-name>C1</port-name>
</destination>
</connection-map>
- <otsigroup-capability-profile>
- <profile-name>otsigroup-profile1</profile-name>
- <if-cap-type xmlns:org-openroadm-port-types="http://org/openroadm/port/types">org-openroadm-port-types:if-OTUCn-ODUCn</if-cap-type>
- <otucn-n-rate>4</otucn-n-rate>
- <foic-type xmlns:org-openroadm-common-optical-channel-types="http://org/openroadm/common-optical-channel-types">org-openroadm-common-optical-channel-types:foic4.8</foic-type>
- <otn-odu-mux-hierarchy-profile-name>one-stage-ODUCn-ODUflex-ODU4</otn-odu-mux-hierarchy-profile-name>
- </otsigroup-capability-profile>
<mc-capability-profile>
<profile-name>mc-capa-profile1</profile-name>
<center-freq-granularity>3.125</center-freq-granularity>
<max-slots>14</max-slots>
</mc-capability-profile>
</org-openroadm-device>
-</data>
+</data>
\ No newline at end of file
<port-name>C1</port-name>
</destination>
</connection-map>
+ <mc-capability-profile>
+ <profile-name>mc-capa-profile1</profile-name>
+ <center-freq-granularity>3.125</center-freq-granularity>
+ <min-edge-freq>191.325</min-edge-freq>
+ <max-edge-freq>196.125</max-edge-freq>
+ <slot-width-granularity>6.25</slot-width-granularity>
+ <min-slots>1</min-slots>
+ <max-slots>14</max-slots>
+ </mc-capability-profile>
</org-openroadm-device>
- <current-pm-list xmlns="http://org/openroadm/pm">
- <current-pm-entry>
- <pm-resource-instance xmlns:d="http://org/openroadm/device">/d:org-openroadm-device/d:interface[d:name='XPDR1-NETWORK1-OTU']</pm-resource-instance>
- <pm-resource-type>interface</pm-resource-type>
- <pm-resource-type-extension></pm-resource-type-extension>
- <retrieval-time>2018-06-07T13:22:58+00:00</retrieval-time>
- <current-pm>
- <type>opticalPowerOutput</type>
- <extension></extension>
- <location>nearEnd</location>
- <direction>tx</direction>
- <measurement>
- <granularity>15min</granularity>
- <pmParameterValue>2.5</pmParameterValue>
- <pmParameterUnit>dBm</pmParameterUnit>
- <validity>complete</validity>
- </measurement>
- <measurement>
- <granularity>24Hour</granularity>
- <pmParameterValue>2.23</pmParameterValue>
- <pmParameterUnit>dBm</pmParameterUnit>
- <validity>complete</validity>
- </measurement>
- </current-pm>
- <current-pm>
- <type>opticalPowerInput</type>
- <extension></extension>
- <location>nearEnd</location>
- <direction>rx</direction>
- <measurement>
- <granularity>15min</granularity>
- <pmParameterValue>-45.1</pmParameterValue>
- <pmParameterUnit>dBm</pmParameterUnit>
- <validity>complete</validity>
- </measurement>
- <measurement>
- <granularity>24Hour</granularity>
- <pmParameterValue>-49.3</pmParameterValue>
- <pmParameterUnit>dBm</pmParameterUnit>
- <validity>complete</validity>
- </measurement>
- </current-pm>
- </current-pm-entry>
-</current-pm-list>
</data>
"node-model": "model1",
"node-ip-address": "1.2.3.4"
},
- "mapping": [],
+ "mapping": [
+ {
+ "logical-connection-point": "XPDR1-CLIENT1",
+ "port-qual": "xpdr-client"
+ }
+ ],
"mc-capabilities": [],
"cp-to-degree": [],
"switching-pool-lcp": []
"node-model": "model1",
"node-ip-address": "1.2.3.4"
},
- "mapping": [],
+ "mapping": [
+ {
+ "logical-connection-point": "XPDR1-CLIENT1",
+ "port-qual": "xpdr-client"
+ }
+ ],
"mc-capabilities": [],
"cp-to-degree": [],
"switching-pool-lcp": []
"node-model": "model1",
"node-ip-address": "1.2.3.4"
},
- "mapping": [],
+ "mapping": [
+ {
+ "logical-connection-point": "XPDR1-CLIENT1",
+ "port-qual": "xpdr-client"
+ }
+ ],
"mc-capabilities": [],
"cp-to-degree": [],
"switching-pool-lcp": []
"node-model": "model1",
"node-ip-address": "1.2.3.4"
},
- "mapping": [],
+ "mapping": [
+ {
+ "logical-connection-point": "XPDR1-CLIENT1",
+ "port-qual": "xpdr-client"
+ }
+ ],
"mc-capabilities": [],
"cp-to-degree": [],
"switching-pool-lcp": []
"node-model": "model1",
"node-ip-address": "1.2.3.4"
},
- "mapping": [],
+ "mapping": [
+ {
+ "logical-connection-point": "XPDR1-CLIENT1",
+ "port-qual": "xpdr-client"
+ }
+ ],
"mc-capabilities": [],
"cp-to-degree": [],
"switching-pool-lcp": []
{
"network": {
"nodes": [
+ {
+ "node-id": "XPDR-A2",
+ "node-info": {
+ "node-clli": "NodeA",
+ "node-vendor": "vendorA",
+ "openroadm-version": "7.1",
+ "node-ip-address": "1.2.3.4",
+ "node-type": "xpdr",
+ "node-model": "model"
+ },
+ "switching-pool-lcp": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 2,
+ "lcp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT2"
+ ],
+ "interconnect-bandwidth": 0
+ },
+ {
+ "nbl-number": 1,
+ "lcp-list": [
+ "XPDR2-CLIENT1",
+ "XPDR2-NETWORK1"
+ ],
+ "interconnect-bandwidth": 0
+ }
+ ]
+ }
+ ],
+ "mapping": [
+ {
+ "logical-connection-point": "XPDR2-CLIENT1",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/2/1/1-PLUG-CLIENT",
+ "mpdr-restrictions": {
+ "min-trib-slot": "1.1",
+ "max-trib-slot": "1.20"
+ },
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-100GE-ODU4",
+ "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ ],
+ "port-oper-state": "InService",
+ "port-direction": "bidirectional",
+ "lcp-hash-val": "AK+Cna4EclRH",
+ "supporting-port": "C1",
+ "port-qual": "switch-client"
+ },
+ {
+ "logical-connection-point": "XPDR1-NETWORK1",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/1/2-PLUG-NET",
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-otsi-otsigroup"
+ ],
+ "port-oper-state": "InService",
+ "connection-map-lcp": "XPDR1-CLIENT1",
+ "port-direction": "bidirectional",
+ "xponder-type": "tpdr",
+ "lcp-hash-val": "AIGiVAQ4gDil",
+ "supporting-port": "L1",
+ "port-qual": "xpdr-network"
+ },
+ {
+ "logical-connection-point": "XPDR2-CLIENT2",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/2/1/2-PLUG-CLIENT",
+ "mpdr-restrictions": {
+ "min-trib-slot": "2.1",
+ "max-trib-slot": "2.20"
+ },
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-100GE-ODU4",
+ "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ ],
+ "port-oper-state": "InService",
+ "port-direction": "bidirectional",
+ "lcp-hash-val": "AK+Cna4EclRE",
+ "supporting-port": "C1",
+ "port-qual": "switch-client"
+ },
+ {
+ "logical-connection-point": "XPDR1-CLIENT1",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/1/1-PLUG-CLIENT",
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-400GE"
+ ],
+ "port-oper-state": "InService",
+ "connection-map-lcp": "XPDR1-NETWORK1",
+ "port-direction": "bidirectional",
+ "lcp-hash-val": "AODABTVSOHH0",
+ "supporting-port": "C1",
+ "port-qual": "xpdr-client"
+ },
+ {
+ "logical-connection-point": "XPDR2-NETWORK1",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/2/2-PLUG-NET",
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-otsi-otsigroup"
+ ],
+ "port-oper-state": "InService",
+ "port-direction": "bidirectional",
+ "xponder-type": "mpdr",
+ "lcp-hash-val": "LY9PxYJqUbw=",
+ "supporting-port": "L1",
+ "port-qual": "switch-network"
+ }
+ ],
+ "mc-capabilities": [
+ {
+ "mc-node-name": "XPDR-mcprofile",
+ "center-freq-granularity": 3.125,
+ "slot-width-granularity": 6.25
+ }
+ ]
+ },
{
"node-id": "ROADM-C1",
"node-info": {
- "node-type": "rdm",
- "node-model": "model2",
- "node-ip-address": "127.0.0.13",
"node-clli": "NodeC",
+ "node-vendor": "vendorA",
"openroadm-version": "2.2.1",
- "node-vendor": "vendorA"
+ "node-ip-address": "127.0.0.13",
+ "node-type": "rdm",
+ "node-model": "model2"
},
"cp-to-degree": [
{
],
"mapping": [
{
- "logical-connection-point": "SRG1-PP3-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "SRG1-PP2-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C3"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C2",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG1-PP1-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "SRG1-PP4-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C1"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C4",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "DEG1-TTP-TXRX",
- "supporting-oms": "OMS-DEG1-TTP-TXRX",
- "supporting-circuit-pack-name": "1/0",
- "supporting-ots": "OTS-DEG1-TTP-TXRX",
+ "logical-connection-point": "DEG2-TTP-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "L1"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "2/0",
+ "supporting-port": "L1",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG1-PP2-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "SRG1-PP3-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C2"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C3",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG1-PP4-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "DEG1-TTP-TXRX",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/0",
+ "supporting-ots": "OTS-DEG1-TTP-TXRX",
+ "port-oper-state": "InService",
"port-direction": "bidirectional",
- "supporting-port": "C4"
+ "supporting-port": "L1",
+ "supporting-oms": "OMS-DEG1-TTP-TXRX"
},
{
- "logical-connection-point": "DEG2-TTP-TXRX",
- "supporting-circuit-pack-name": "2/0",
+ "logical-connection-point": "SRG1-PP1-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "L1"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C1",
+ "port-oper-state": "InService"
}
],
"mc-capabilities": [
]
},
{
- "node-id": "XPDR-A2",
+ "node-id": "XPDR-C2",
+ "node-info": {
+ "node-clli": "NodeC",
+ "node-vendor": "vendorA",
+ "openroadm-version": "7.1",
+ "node-ip-address": "1.2.3.4",
+ "node-type": "xpdr",
+ "node-model": "model"
+ },
+ "switching-pool-lcp": [
+ {
+ "switching-pool-number": 1,
+ "switching-pool-type": "blocking",
+ "non-blocking-list": [
+ {
+ "nbl-number": 2,
+ "lcp-list": [
+ "XPDR2-NETWORK1",
+ "XPDR2-CLIENT2"
+ ],
+ "interconnect-bandwidth": 0
+ },
+ {
+ "nbl-number": 1,
+ "lcp-list": [
+ "XPDR2-CLIENT1",
+ "XPDR2-NETWORK1"
+ ],
+ "interconnect-bandwidth": 0
+ }
+ ]
+ }
+ ],
"mapping": [
+ {
+ "logical-connection-point": "XPDR2-CLIENT1",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/2/1/1-PLUG-CLIENT",
+ "mpdr-restrictions": {
+ "min-trib-slot": "1.1",
+ "max-trib-slot": "1.20"
+ },
+ "supported-interface-capability": [
+ "org-openroadm-port-types:if-100GE-ODU4",
+ "org-openroadm-port-types:if-OCH-OTU4-ODU4"
+ ],
+ "port-oper-state": "InService",
+ "port-direction": "bidirectional",
+ "lcp-hash-val": "AP2/mp+mI1y5",
+ "supporting-port": "C1",
+ "port-qual": "switch-client"
+ },
{
"logical-connection-point": "XPDR1-NETWORK1",
- "supporting-circuit-pack-name": "1/0/1-PLUG-NET",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/1/2-PLUG-NET",
"supported-interface-capability": [
- "org-openroadm-port-types:if-OTUCn-ODUCn"
+ "org-openroadm-port-types:if-otsi-otsigroup"
],
- "lcp-hash-val": "AIGiVAQ4gDil",
+ "port-oper-state": "InService",
+ "connection-map-lcp": "XPDR1-CLIENT1",
"port-direction": "bidirectional",
"xponder-type": "tpdr",
+ "lcp-hash-val": "ZbICgmaBrJM=",
"supporting-port": "L1",
- "port-qual": "xpdr-network",
- "connection-map-lcp": "XPDR1-CLIENT1"
+ "port-qual": "xpdr-network"
},
{
- "logical-connection-point": "XPDR1-CLIENT1",
- "supporting-circuit-pack-name": "1/0/1-PLUG-CLIENT",
+ "logical-connection-point": "XPDR2-CLIENT2",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/2/1/2-PLUG-CLIENT",
+ "mpdr-restrictions": {
+ "min-trib-slot": "2.1",
+ "max-trib-slot": "2.20"
+ },
"supported-interface-capability": [
- "org-openroadm-port-types:if-400GE"
+ "org-openroadm-port-types:if-100GE-ODU4",
+ "org-openroadm-port-types:if-OCH-OTU4-ODU4"
],
- "lcp-hash-val": "AODABTVSOHH0",
+ "port-oper-state": "InService",
"port-direction": "bidirectional",
+ "lcp-hash-val": "AP2/mp+mI1y6",
"supporting-port": "C1",
- "port-qual": "xpdr-client",
- "connection-map-lcp": "XPDR1-NETWORK1"
- }
- ],
- "node-info": {
- "node-type": "xpdr",
- "node-model": "model2",
- "node-ip-address": "1.2.3.4",
- "node-clli": "NodeA",
- "openroadm-version": "7.1",
- "node-vendor": "vendorA"
- }
- },
- {
- "node-id": "XPDR-C2",
- "mapping": [
+ "port-qual": "switch-client"
+ },
{
- "logical-connection-point": "XPDR1-NETWORK1",
- "supporting-circuit-pack-name": "1/0/1-PLUG-NET",
+ "logical-connection-point": "XPDR1-CLIENT1",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/1/1-PLUG-CLIENT",
"supported-interface-capability": [
- "org-openroadm-port-types:if-OTUCn-ODUCn"
+ "org-openroadm-port-types:if-400GE"
],
- "lcp-hash-val": "ZbICgmaBrJM=",
+ "port-oper-state": "InService",
+ "connection-map-lcp": "XPDR1-NETWORK1",
"port-direction": "bidirectional",
- "xponder-type": "tpdr",
- "supporting-port": "L1",
- "port-qual": "xpdr-network",
- "connection-map-lcp": "XPDR1-CLIENT1"
+ "lcp-hash-val": "M5cViLS5z3o=",
+ "supporting-port": "C1",
+ "port-qual": "xpdr-client"
},
{
- "logical-connection-point": "XPDR1-CLIENT1",
- "supporting-circuit-pack-name": "1/0/1-PLUG-CLIENT",
+ "logical-connection-point": "XPDR2-NETWORK1",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/2/2-PLUG-NET",
"supported-interface-capability": [
- "org-openroadm-port-types:if-400GE"
+ "org-openroadm-port-types:if-otsi-otsigroup"
],
- "lcp-hash-val": "M5cViLS5z3o=",
+ "port-oper-state": "InService",
"port-direction": "bidirectional",
- "supporting-port": "C1",
- "port-qual": "xpdr-client",
- "connection-map-lcp": "XPDR1-NETWORK1"
+ "xponder-type": "mpdr",
+ "lcp-hash-val": "Nmbu2MNHvc4=",
+ "supporting-port": "L1",
+ "port-qual": "switch-network"
}
],
- "node-info": {
- "node-type": "xpdr",
- "node-model": "model2",
- "node-ip-address": "1.2.3.4",
- "node-clli": "NodeC",
- "openroadm-version": "7.1",
- "node-vendor": "vendorA"
- }
+ "mc-capabilities": [
+ {
+ "mc-node-name": "XPDR-mcprofile",
+ "center-freq-granularity": 3.125,
+ "slot-width-granularity": 6.25
+ }
+ ]
},
{
"node-id": "ROADM-A1",
"node-info": {
- "node-type": "rdm",
- "node-model": "model2",
- "node-ip-address": "127.0.0.11",
"node-clli": "NodeA",
+ "node-vendor": "vendorA",
"openroadm-version": "2.2.1",
- "node-vendor": "vendorA"
+ "node-ip-address": "127.0.0.11",
+ "node-type": "rdm",
+ "node-model": "model2"
},
"cp-to-degree": [
{
],
"mapping": [
{
- "logical-connection-point": "SRG1-PP3-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "SRG3-PP1-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C3"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "5/0",
+ "supporting-port": "C1",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG3-PP2-TXRX",
- "supporting-circuit-pack-name": "5/0",
+ "logical-connection-point": "SRG1-PP2-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C2"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C2",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG1-PP1-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "SRG3-PP4-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C1"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "5/0",
+ "supporting-port": "C4",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "DEG1-TTP-TXRX",
- "supporting-circuit-pack-name": "1/0",
+ "logical-connection-point": "SRG1-PP4-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "L1"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C4",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG3-PP1-TXRX",
- "supporting-circuit-pack-name": "5/0",
+ "logical-connection-point": "SRG3-PP3-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C1"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "5/0",
+ "supporting-port": "C3",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG1-PP2-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "DEG2-TTP-TXRX",
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "2/0",
+ "supporting-ots": "OTS-DEG2-TTP-TXRX",
+ "port-oper-state": "InService",
"port-direction": "bidirectional",
- "supporting-port": "C2"
+ "supporting-port": "L1",
+ "supporting-oms": "OMS-DEG2-TTP-TXRX"
},
{
- "logical-connection-point": "SRG1-PP4-TXRX",
- "supporting-circuit-pack-name": "3/0",
+ "logical-connection-point": "SRG1-PP3-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C4"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C3",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG3-PP4-TXRX",
- "supporting-circuit-pack-name": "5/0",
+ "logical-connection-point": "SRG3-PP2-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C4"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "5/0",
+ "supporting-port": "C2",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "SRG3-PP3-TXRX",
- "supporting-circuit-pack-name": "5/0",
+ "logical-connection-point": "DEG1-TTP-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "C3"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "1/0",
+ "supporting-port": "L1",
+ "port-oper-state": "InService"
},
{
- "logical-connection-point": "DEG2-TTP-TXRX",
- "supporting-oms": "OMS-DEG2-TTP-TXRX",
- "supporting-circuit-pack-name": "2/0",
- "supporting-ots": "OTS-DEG2-TTP-TXRX",
+ "logical-connection-point": "SRG1-PP1-TXRX",
"port-direction": "bidirectional",
- "supporting-port": "L1"
+ "port-admin-state": "InService",
+ "supporting-circuit-pack-name": "3/0",
+ "supporting-port": "C1",
+ "port-oper-state": "InService"
}
],
"mc-capabilities": [
TOPO_BI_DIR_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"..", "..", "sample_configs", "honeynode-topo400G.json")
with open(TOPO_BI_DIR_FILE, 'r') as topo_bi_dir:
- cls.simple_topo_bi_dir_data = topo_bi_dir.read()
+ cls.topo_bi_dir_data = topo_bi_dir.read()
+
+ OTN_TOPO_BI_DIR_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "sample_configs", "honeynode-otntopo400G.json")
+ with open(OTN_TOPO_BI_DIR_FILE, 'r') as otn_topo_bi_dir:
+ cls.otn_topo_bi_dir_data = otn_topo_bi_dir.read()
+
+ OTUC4_OTN_TOPO_BI_DIR_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "sample_configs", "honeynode-otntopo400GwithOTUC4.json")
+ with open(OTUC4_OTN_TOPO_BI_DIR_FILE, 'r') as otuc4_otn_topo_bi_dir:
+ cls.otuc4_otn_topo_bi_dir_data = otuc4_otn_topo_bi_dir.read()
+
+ ODUC4_OTN_TOPO_BI_DIR_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)),
+ "..", "..", "sample_configs", "honeynode-otntopo400GwithODUC4.json")
+ with open(ODUC4_OTN_TOPO_BI_DIR_FILE, 'r') as oduc4_otn_topo_bi_dir:
+ cls.oduc4_otn_topo_bi_dir_data = oduc4_otn_topo_bi_dir.read()
PORT_MAPPING_FILE = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"..", "..", "sample_configs", "pce_portmapping_71.json")
self.assertIn(response.status_code, (requests.codes.ok, requests.codes.created))
time.sleep(2)
- # Load simple bidirectional topology
- def test_02_load_simple_topology_bi(self):
- response = test_utils.put_jsonrequest(test_utils.URL_CONFIG_ORDM_TOPO, self.simple_topo_bi_dir_data)
+ # Load openroadm topology
+ def test_02_load_openroadm_topology_bi(self):
+ response = test_utils.put_jsonrequest(test_utils.URL_CONFIG_ORDM_TOPO, self.topo_bi_dir_data)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
# Path Computation success
- def test_03_path_computation_xpdr_bi(self):
+ def test_03_path_computation_400G_xpdr_bi(self):
response = test_utils.path_computation_request("request-1", "service-1",
{"node-id": "XPDR-A2", "service-rate": "400",
"service-format": "Ethernet", "clli": "nodeA"},
['zToA-direction']['modulation-format'])
time.sleep(5)
- # Test deleted complex topology
- def test_04_test_topology_complex_deleted(self):
- response = test_utils.get_ordm_topo_request("node/XPONDER-3-2")
- self.assertEqual(response.status_code, requests.codes.conflict)
- time.sleep(1)
+ # Load otn topology
+ def test_04_load_otn_topology_bi(self):
+ response = test_utils.put_jsonrequest(test_utils.URL_CONFIG_OTN_TOPO, self.otn_topo_bi_dir_data)
+ self.assertEqual(response.status_code, requests.codes.ok)
+ time.sleep(2)
+
+ # Path Computation success
+ def test_05_path_computation_OTUC4_xpdr_bi(self):
+ response = test_utils.path_computation_request("request-1", "service-OTUC4",
+ {"service-rate": "400", "clli": "NodeA",
+ "service-format": "OTU", "node-id": "XPDR-A2",
+ "rx-direction": {"port": {"port-device-name": "XPDR-A2-XPDR2"}}
+ },
+ {"service-rate": "400", "clli": "NodeC",
+ "service-format": "OTU", "node-id": "XPDR-C2",
+ "rx-direction": {"port": {"port-device-name": "XPDR-C2-XPDR2"}}
+ })
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.assertIn('Path is calculated',
+ res['output']['configuration-response-common']['response-message'])
+
+ self.assertEqual(1, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['aToZ-wavelength-number'])
+ self.assertEqual(400, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['rate'])
+ self.assertEqual(196.0375, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['aToZ-min-frequency'])
+ self.assertEqual(196.12500, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['aToZ-max-frequency'])
+ self.assertEqual('dp-qam16', res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['modulation-format'])
+
+ self.assertEqual(1, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['zToA-wavelength-number'])
+ self.assertEqual(400, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['rate'])
+ self.assertEqual(196.0375, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['zToA-min-frequency'])
+ self.assertEqual(196.12500, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['zToA-max-frequency'])
+ self.assertEqual('dp-qam16', res['output']['response-parameters']['path-description']
+ ['zToA-direction']['modulation-format'])
+ time.sleep(5)
+
+ # Load otn topology with OTUC4 links
+ def test_06_load_otuc4_otn_topology_bi(self):
+ response = test_utils.put_jsonrequest(test_utils.URL_CONFIG_OTN_TOPO, self.otuc4_otn_topo_bi_dir_data)
+ self.assertEqual(response.status_code, requests.codes.ok)
+ time.sleep(2)
+
+ # Path Computation success
+ def test_07_path_computation_ODUC4_xpdr_bi(self):
+ response = test_utils.path_computation_request("request-1", "service-ODUC4",
+ {"service-rate": "400", "clli": "NodeA", "service-format": "ODU",
+ "node-id": "XPDR-A2-XPDR2",
+ "tx-direction": {"port": {"port-device-name": "XPDR-A2-XPDR2"}}
+ },
+ {"service-rate": "400", "clli": "NodeC", "service-format": "ODU",
+ "node-id": "XPDR-C2-XPDR2",
+ "tx-direction": {"port": {"port-device-name": "XPDR-C2-XPDR2"}}
+ })
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.assertIn('Path is calculated',
+ res['output']['configuration-response-common']['response-message'])
+
+ self.assertEqual(400, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['rate'])
+ self.assertEqual('dp-qam16', res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['modulation-format'])
+
+ self.assertEqual(400, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['rate'])
+ self.assertEqual('dp-qam16', res['output']['response-parameters']['path-description']
+ ['zToA-direction']['modulation-format'])
+ time.sleep(5)
- # Delete portmapping
- def test_05_delete_port_mapping(self):
- response = test_utils.delete_request(test_utils.URL_FULL_PORTMAPPING)
+ # Load otn topology with OTUC4 links
+ def test_08_load_oduc4_otn_topology_bi(self):
+ response = test_utils.put_jsonrequest(test_utils.URL_CONFIG_OTN_TOPO, self.oduc4_otn_topo_bi_dir_data)
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(2)
+ # Path Computation success
+ def test_09_path_computation_100G_xpdr_bi(self):
+ response = test_utils.path_computation_request("request-1", "service-100GE",
+ {"service-rate": "100", "clli": "NodeA", "service-format": "Ethernet",
+ "node-id": "XPDR-A2",
+ "tx-direction": {"port": {"port-device-name": "XPDR-A2-XPDR2",
+ "port-name": "XPDR2-CLIENT1"}}},
+ {"service-rate": "100", "clli": "NodeC", "service-format": "Ethernet",
+ "node-id": "XPDR-C2",
+ "tx-direction": {"port": {"port-device-name": "XPDR-C2-XPDR2",
+ "port-name": "XPDR2-CLIENT1"}}})
+
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.assertIn('Path is calculated',
+ res['output']['configuration-response-common']['response-message'])
+
+ self.assertEqual(100, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['rate'])
+ self.assertEqual(1, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['trib-port-number'])
+ self.assertEqual(1, res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['trib-slot-number'])
+ self.assertEqual('dp-qpsk', res['output']['response-parameters']['path-description']
+ ['aToZ-direction']['modulation-format'])
+
+ self.assertEqual(100, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['rate'])
+ self.assertEqual(1, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['trib-port-number'])
+ self.assertEqual(1, res['output']['response-parameters']['path-description']
+ ['zToA-direction']['trib-slot-number'])
+ self.assertEqual('dp-qpsk', res['output']['response-parameters']['path-description']
+ ['zToA-direction']['modulation-format'])
+ time.sleep(5)
if __name__ == "__main__":
unittest.main(verbosity=2)
'port-admin-state': 'InService', 'port-oper-state': 'InService'},
res['mapping'])
- def test_06_xpdr_device_disconnection(self):
+ # Check the port-mapping for the switch-client and switch-network port-quals
+ def test_06_xpdr2_portmapping_NETWORK1(self):
+ response = test_utils.portmapping_request("XPDR-A2/mapping/XPDR2-NETWORK1")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.assertIn(
+ {'supported-interface-capability':
+ ['org-openroadm-port-types:if-otsi-otsigroup'],
+ 'supporting-port': 'L2',
+ 'supporting-circuit-pack-name': '1/0/7-PLUG-NETWORK',
+ 'logical-connection-point': 'XPDR2-NETWORK1',
+ 'port-qual': 'switch-network',
+ 'port-direction': 'bidirectional',
+ 'lcp-hash-val': 'LY9PxYJqUbw=',
+ 'port-admin-state': 'InService',
+ 'port-oper-state': 'InService',
+ 'xponder-type': 'mpdr'
+ },
+ res['mapping'])
+
+ def test_07_xpdr2_portmapping_CLIENT1(self):
+ response = test_utils.portmapping_request("XPDR-A2/mapping/XPDR2-CLIENT1")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.assertIn(
+ {'supported-interface-capability':
+ ['org-openroadm-port-types:if-100GE-ODU4',
+ 'org-openroadm-port-types:if-OCH-OTU4-ODU4'],
+ 'supporting-port': 'C3',
+ 'supporting-circuit-pack-name': '1/0/3-PLUG-CLIENT',
+ 'logical-connection-point': 'XPDR2-CLIENT1',
+ 'port-direction': 'bidirectional',
+ 'port-qual': 'switch-client',
+ 'lcp-hash-val': 'AK+Cna4EclRH',
+ 'port-admin-state': 'InService',
+ 'port-oper-state': 'InService',
+ "mpdr-restrictions": {
+ "min-trib-slot": "1.1",
+ "max-trib-slot": "1.20"
+ }},
+ res['mapping'])
+
+ # Added test to check mc-capability-profile for a transponder
+ def test_08_check_mccapprofile(self):
+ response = test_utils.portmapping_request("XPDR-A2/mc-capabilities/XPDR-mcprofile")
+ self.assertEqual(response.status_code, requests.codes.ok)
+ res = response.json()
+ self.assertEqual(res['mc-capabilities'][0]['mc-node-name'], 'XPDR-mcprofile')
+ self.assertEqual(res['mc-capabilities'][0]['center-freq-granularity'], 3.125)
+ self.assertEqual(res['mc-capabilities'][0]['slot-width-granularity'], 6.25)
+
+ def test_09_xpdr_device_disconnection(self):
response = test_utils.unmount_device("XPDR-A2")
self.assertEqual(response.status_code, requests.codes.ok, test_utils.CODE_SHOULD_BE_200)
- def test_07_xpdr_device_disconnected(self):
+ def test_10_xpdr_device_disconnected(self):
response = test_utils.get_netconf_oper_request("XPDR-A2")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
"relevant data model content does not exist"},
res['errors']['error'])
- def test_08_xpdr_device_not_connected(self):
+ def test_11_xpdr_device_not_connected(self):
response = test_utils.portmapping_request("XPDR-A2")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
Code Review / transportpce.git / commitdiff