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;
+ }
+
+}
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);
<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
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);
}
}
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);
.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.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;
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) {
<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
Code Review / transportpce.git / commitdiff