X-Git-Url: https://git.opendaylight.org/gerrit/gitweb?a=blobdiff_plain;f=common%2Fsrc%2Fmain%2Fjava%2Forg%2Fopendaylight%2Ftransportpce%2Fcommon%2Fcrossconnect%2FCrossConnectImpl221.java;h=529af506c4335d0f87a9bb913add82f4e7de2ac5;hb=refs%2Fchanges%2F46%2F100646%2F27;hp=4e5e2163b6eb8fe54570e1a8513305878ef4fd20;hpb=53375cfd7601ff17bf225f78d4e01dc649960e65;p=transportpce.git diff --git a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java index 4e5e2163b..529af506c 100644 --- a/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java +++ b/common/src/main/java/org/opendaylight/transportpce/common/crossconnect/CrossConnectImpl221.java @@ -7,35 +7,44 @@ */ package org.opendaylight.transportpce.common.crossconnect; -import com.google.common.util.concurrent.ListenableFuture; -import java.math.BigDecimal; +import com.google.common.util.concurrent.FluentFuture; import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Optional; import java.util.concurrent.ExecutionException; import java.util.concurrent.Future; - -import org.opendaylight.controller.md.sal.binding.api.MountPoint; -import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType; -import org.opendaylight.controller.sal.binding.api.RpcConsumerRegistry; +import org.eclipse.jdt.annotation.NonNull; +import org.opendaylight.mdsal.binding.api.MountPoint; +import org.opendaylight.mdsal.binding.api.RpcConsumerRegistry; +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.transportpce.common.fixedflex.GridConstant; +import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation; import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.OpticalControlMode; import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PowerDBm; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.GetConnectionPortTrailInputBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.GetConnectionPortTrailOutput; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.OduConnection.Direction; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.OrgOpenroadmDeviceData; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.OrgOpenroadmDeviceService; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.connection.DestinationBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.connection.SourceBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.get.connection.port.trail.output.Ports; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.OrgOpenroadmDevice; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnection; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionBuilder; +import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.OduConnectionKey; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnections; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsBuilder; import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey; +import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210930.otn.renderer.nodes.Nodes; import org.opendaylight.yangtools.yang.binding.InstanceIdentifier; +import org.opendaylight.yangtools.yang.common.Decimal64; import org.opendaylight.yangtools.yang.common.RpcResult; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -43,6 +52,8 @@ import org.slf4j.LoggerFactory; public class CrossConnectImpl221 { private static final Logger LOG = LoggerFactory.getLogger(CrossConnectImpl221.class); + private static final String DEV_TRANSACTION_NOT_FOUND = "Device transaction for device {} was not found!"; + private static final String UNABLE_DEV_TRANSACTION = "Unable to obtain device transaction for device {}!"; private final DeviceTransactionManager deviceTransactionManager; public CrossConnectImpl221(DeviceTransactionManager deviceTransactionManager) { @@ -56,21 +67,31 @@ public class CrossConnectImpl221 { Timeouts.DEVICE_READ_TIMEOUT_UNIT); } + public Optional getOtnCrossConnect(String deviceId, String connectionNumber) { + //TODO Change it to Operational later for real device + return deviceTransactionManager.getDataFromDevice(deviceId, LogicalDatastoreType.CONFIGURATION, + generateOduConnectionIID(connectionNumber), Timeouts.DEVICE_READ_TIMEOUT, + Timeouts.DEVICE_READ_TIMEOUT_UNIT); + } - public Optional postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp) { - RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder(); - String connectionNumber = generateConnectionName(srcTp, destTp, waveNumber); - rdmConnBldr.setConnectionName(connectionNumber); - - rdmConnBldr.setOpticalControlMode(OpticalControlMode.Off); - - rdmConnBldr.setSource(new SourceBuilder().setSrcIf(srcTp + "-nmc-" + waveNumber).build()); - - rdmConnBldr.setDestination(new DestinationBuilder().setDstIf(destTp + "-nmc-" + waveNumber).build()); - + public Optional postCrossConnect(String deviceId, String srcTp, String destTp, + SpectrumInformation spectrumInformation) { + String connectionNumber = spectrumInformation.getIdentifierFromParams(srcTp, destTp); + RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder() + .setConnectionName(connectionNumber) + .setOpticalControlMode(OpticalControlMode.Off) + .setSource(new SourceBuilder() + .setSrcIf(spectrumInformation.getIdentifierFromParams(srcTp,"nmc")) + .build()) + .setDestination(new DestinationBuilder() + .setDstIf(spectrumInformation.getIdentifierFromParams(destTp,"nmc")) + .build()); - InstanceIdentifier rdmConnectionIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(RoadmConnections.class, new RoadmConnectionsKey(rdmConnBldr.getConnectionName())); + InstanceIdentifier rdmConnectionIID = InstanceIdentifier + .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class) + .child(RoadmConnections.class, new RoadmConnectionsKey(rdmConnBldr.getConnectionName())) + .build(); Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId); DeviceTransaction deviceTx; @@ -79,42 +100,47 @@ public class CrossConnectImpl221 { if (deviceTxOpt.isPresent()) { deviceTx = deviceTxOpt.get(); } else { - LOG.error("Device transaction for device {} was not found!", deviceId); + LOG.error(DEV_TRANSACTION_NOT_FOUND, deviceId); return Optional.empty(); } } catch (InterruptedException | ExecutionException e) { - LOG.error("Unable to obtain device transaction for device {}!", deviceId, e); + LOG.error(UNABLE_DEV_TRANSACTION, deviceId, e); return Optional.empty(); } // post the cross connect on the device - deviceTx.put(LogicalDatastoreType.CONFIGURATION, rdmConnectionIID, rdmConnBldr.build()); - ListenableFuture submit = - deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + deviceTx.merge(LogicalDatastoreType.CONFIGURATION, rdmConnectionIID, rdmConnBldr.build()); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); try { - submit.get(); - LOG.info("Roadm-connection successfully created: {}-{}-{}", srcTp, destTp, waveNumber); + commit.get(); + LOG.info("Roadm-connection successfully created: {}-{}-{}-{}", srcTp, destTp, + spectrumInformation.getLowerSpectralSlotNumber(), + spectrumInformation.getHigherSpectralSlotNumber()); return Optional.of(connectionNumber); } catch (InterruptedException | ExecutionException e) { - LOG.warn("Failed to post {}. Exception: {}", rdmConnBldr.build(), e); + LOG.warn("Failed to post {}. Exception: ", rdmConnBldr.build(), e); } return Optional.empty(); } - public List deleteCrossConnect(String deviceId, String connectionName) { + public List deleteCrossConnect(String deviceId, String connectionName, boolean isOtn) { List interfList = new ArrayList<>(); Optional xc = getCrossConnect(deviceId, connectionName); + Optional otnXc = getOtnCrossConnect(deviceId, connectionName); //Check if cross connect exists before delete if (xc.isPresent()) { - String name = xc.get().getSource().getSrcIf(); - name.replace("nmc", "mc"); interfList.add(xc.get().getSource().getSrcIf()); interfList.add(xc.get().getDestination().getDstIf()); interfList.add(xc.get().getSource().getSrcIf().replace("nmc", "mc")); interfList.add(xc.get().getDestination().getDstIf().replace("nmc", "mc")); + } else if (otnXc.isPresent()) { + interfList.add(otnXc.get().getSource().getSrcIf()); + interfList.add(otnXc.get().getDestination().getDstIf()); } else { - LOG.warn("Cross connect does not exist, halting delete"); + LOG.warn("Cross connect {} does not exist, halting delete", connectionName); return null; } Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId); @@ -124,21 +150,25 @@ public class CrossConnectImpl221 { if (deviceTxOpt.isPresent()) { deviceTx = deviceTxOpt.get(); } else { - LOG.error("Device transaction for device {} was not found!", deviceId); + LOG.error(DEV_TRANSACTION_NOT_FOUND, deviceId); return null; } } catch (InterruptedException | ExecutionException e) { - LOG.error("Unable to obtain device transaction for device {}!", deviceId, e); + LOG.error(UNABLE_DEV_TRANSACTION, deviceId, e); return null; } // post the cross connect on the device - deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateRdmConnectionIID(connectionName)); - ListenableFuture submit = - deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + if (isOtn) { + deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateOduConnectionIID(connectionName)); + } else { + deviceTx.delete(LogicalDatastoreType.CONFIGURATION, generateRdmConnectionIID(connectionName)); + } + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); try { - submit.get(); - LOG.info("Roadm connection {} successfully deleted on {}", connectionName, deviceId); + commit.get(); + LOG.info("Connection {} successfully deleted on {}", connectionName, deviceId); return interfList; } catch (InterruptedException | ExecutionException e) { LOG.warn("Failed to delete {}", connectionName, e); @@ -147,9 +177,13 @@ public class CrossConnectImpl221 { } - public List getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp) + public List getConnectionPortTrail(String nodeId, String srcTp, String destTp, + int lowerSpectralSlotNumber, int higherSpectralSlotNumber) throws OpenRoadmInterfaceException { - String connectionName = generateConnectionName(srcTp, destTp, waveNumber); + String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR, + String.valueOf(lowerSpectralSlotNumber), + String.valueOf(higherSpectralSlotNumber)); + String connectionName = generateConnectionName(srcTp, destTp, spectralSlotName); Optional mountPointOpt = deviceTransactionManager.getDeviceMountPoint(nodeId); List ports = null; MountPoint mountPoint; @@ -159,7 +193,7 @@ public class CrossConnectImpl221 { LOG.error("Failed to obtain mount point for device {}!", nodeId); return Collections.emptyList(); } - final Optional service = mountPoint.getService(RpcConsumerRegistry.class).toJavaUtil(); + final Optional service = mountPoint.getService(RpcConsumerRegistry.class); if (!service.isPresent()) { LOG.error("Failed to get RpcService for node {}", nodeId); } @@ -191,11 +225,11 @@ public class CrossConnectImpl221 { } - public boolean setPowerLevel(String deviceId, Enum mode, BigDecimal powerValue, String connectionName) { - Optional rdmConnOpt = getCrossConnect(deviceId, connectionName); + public boolean setPowerLevel(String deviceId, OpticalControlMode mode, Decimal64 powerValue, String ctName) { + Optional rdmConnOpt = getCrossConnect(deviceId, ctName); if (rdmConnOpt.isPresent()) { RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder(rdmConnOpt.get()); - rdmConnBldr.setOpticalControlMode(OpticalControlMode.values()[mode.ordinal()]); + rdmConnBldr.setOpticalControlMode(mode); if (powerValue != null) { rdmConnBldr.setTargetOutputPower(new PowerDBm(powerValue)); } @@ -218,13 +252,15 @@ public class CrossConnectImpl221 { } // post the cross connect on the device - InstanceIdentifier roadmConnIID = InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(RoadmConnections.class, new RoadmConnectionsKey(connectionName)); - deviceTx.put(LogicalDatastoreType.CONFIGURATION, roadmConnIID, newRdmConn); - ListenableFuture submit = deviceTx.submit(Timeouts.DEVICE_WRITE_TIMEOUT, - Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + InstanceIdentifier roadmConnIID = InstanceIdentifier + .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class) + .child(RoadmConnections.class, new RoadmConnectionsKey(ctName)) + .build(); + deviceTx.merge(LogicalDatastoreType.CONFIGURATION, roadmConnIID, newRdmConn); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); try { - submit.get(); + commit.get(); LOG.info("Roadm connection power level successfully set "); return true; } catch (InterruptedException | ExecutionException ex) { @@ -232,17 +268,74 @@ public class CrossConnectImpl221 { } } else { - LOG.warn("Roadm-Connection is null in set power level ({})", connectionName); + LOG.warn("Roadm-Connection is null in set power level ({})", ctName); } return false; } private InstanceIdentifier generateRdmConnectionIID(String connectionNumber) { - return InstanceIdentifier.create(OrgOpenroadmDevice.class) - .child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber)); + return InstanceIdentifier + .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class) + .child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber)) + .build(); } - private String generateConnectionName(String srcTp, String destTp, Long waveNumber) { - return srcTp + "-" + destTp + "-" + waveNumber; + private InstanceIdentifier generateOduConnectionIID(String connectionNumber) { + return InstanceIdentifier + .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class) + .child(OduConnection.class, new OduConnectionKey(connectionNumber)) + .build(); + } + + private String generateConnectionName(String srcTp, String destTp, String spectralSlotName) { + return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,srcTp, destTp, spectralSlotName); + } + + public Optional postOtnCrossConnect(List createdOduInterfaces, Nodes node) { + String deviceId = node.getNodeId(); + List sortedCreatedOduInterfaces = new ArrayList<>(createdOduInterfaces); + sortedCreatedOduInterfaces.sort((s1,s2) -> s1.compareTo(s2)); + String srcTp = sortedCreatedOduInterfaces.get(0); + String dstTp = sortedCreatedOduInterfaces.get(1); + OduConnectionBuilder oduConnectionBuilder = new OduConnectionBuilder() + .setConnectionName(srcTp + "-x-" + dstTp) + .setDestination(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.odu.connection + .DestinationBuilder().setDstIf(dstTp).build()) + .setSource(new org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.odu.connection + .SourceBuilder().setSrcIf(srcTp).build()) + .setDirection(Direction.Bidirectional); + + InstanceIdentifier oduConnectionIID = InstanceIdentifier + .builderOfInherited(OrgOpenroadmDeviceData.class, OrgOpenroadmDevice.class) + .child(OduConnection.class, new OduConnectionKey(oduConnectionBuilder.getConnectionName())) + .build(); + + Future> deviceTxFuture = deviceTransactionManager.getDeviceTransaction(deviceId); + DeviceTransaction deviceTx; + try { + Optional deviceTxOpt = deviceTxFuture.get(); + if (deviceTxOpt.isPresent()) { + deviceTx = deviceTxOpt.get(); + } else { + LOG.error(DEV_TRANSACTION_NOT_FOUND, deviceId); + return Optional.empty(); + } + } catch (InterruptedException | ExecutionException e) { + LOG.error(UNABLE_DEV_TRANSACTION, deviceId, e); + return Optional.empty(); + } + + // post the cross connect on the device + deviceTx.merge(LogicalDatastoreType.CONFIGURATION, oduConnectionIID, oduConnectionBuilder.build()); + FluentFuture commit = + deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT); + try { + commit.get(); + LOG.info("Otn-connection successfully created: {}-{}", srcTp, dstTp); + return Optional.of(srcTp + "-x-" + dstTp); + } catch (InterruptedException | ExecutionException e) { + LOG.warn("Failed to post {}.", oduConnectionBuilder.build(), e); + } + return Optional.empty(); } -} +} \ No newline at end of file