* Name of source termination point.
* @param destTp
* Name of destination termination point.
+ * @param lowerSpectralSlotNumber Value of lower spectral slot number.
+ * @param higherSpectralSlotNumber Value of higher spectral slot number.
* @return optional of connection number
*/
- Optional<String> postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp);
+ Optional<String> postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber);
/**
* This method does a delete(edit-config) on roadm connection subtree for a
* Source logical connection point.
* @param destTp
* Destination logical connection point.
- *
+ * @param lowerSpectralSlotNumber Value of lower spectral slot number.
+ * @param higherSpectralSlotNumber Value of higher spectral slot number.
* @return list of Ports object type.
*
* @throws OpenRoadmInterfaceException
* an exception at OpenRoadm interface.
*/
- List<?> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp)
+ List<?> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException;
/**
}
- public Optional<String> postCrossConnect(String nodeId, Long waveNumber, String srcTp, String destTp) {
+ public Optional<String> postCrossConnect(String nodeId, Long waveNumber, String srcTp, String destTp,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber) {
String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
LOG.info("Cross Connect post request received for node {} with version {}",nodeId,openRoadmVersion);
if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
LOG.info("Device Version is 1.2.1");
- return crossConnectImpl121.postCrossConnect(nodeId, waveNumber, srcTp, destTp);
+ return crossConnectImpl121.postCrossConnect(nodeId, waveNumber, srcTp, destTp,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
}
else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
LOG.info("Device Version is 2.2");
- return crossConnectImpl221.postCrossConnect(nodeId, waveNumber, srcTp, destTp);
+ return crossConnectImpl221.postCrossConnect(nodeId, srcTp, destTp,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
}
LOG.info("Device Version not found");
return Optional.empty();
return null;
}
- public List<?> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp)
+ public List<?> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
- return crossConnectImpl121.getConnectionPortTrail(nodeId, waveNumber, srcTp, destTp);
+ return crossConnectImpl121.getConnectionPortTrail(nodeId, srcTp, destTp,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
}
else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
- return crossConnectImpl221.getConnectionPortTrail(nodeId, waveNumber, srcTp, destTp);
+ return crossConnectImpl221
+ .getConnectionPortTrail(nodeId, srcTp, destTp, lowerSpectralSlotNumber, higherSpectralSlotNumber);
}
return null;
}
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.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.OpticalControlMode;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.PowerDBm;
Timeouts.DEVICE_READ_TIMEOUT_UNIT);
}
- public Optional<String> postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp) {
+ public Optional<String> postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber) {
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder();
- String connectionNumber = generateConnectionNumber(srcTp, destTp, waveNumber);
+ String connectionNumber = generateConnectionNumber(srcTp, destTp, spectralSlotName);
rdmConnBldr.setConnectionNumber(connectionNumber);
rdmConnBldr.setWavelengthNumber(Uint32.valueOf(waveNumber));
rdmConnBldr.setOpticalControlMode(OpticalControlMode.Off);
- rdmConnBldr.setSource(new SourceBuilder().setSrcIf(srcTp + "-" + waveNumber.toString()).build());
- rdmConnBldr.setDestination(new DestinationBuilder().setDstIf(destTp + "-" + waveNumber.toString()).build());
+ rdmConnBldr.setSource(new SourceBuilder().setSrcIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ srcTp, spectralSlotName)).build());
+ rdmConnBldr.setDestination(new DestinationBuilder()
+ .setDstIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, destTp, spectralSlotName))
+ .build());
InstanceIdentifier<RoadmConnections> rdmConnectionIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(RoadmConnections.class, new RoadmConnectionsKey(rdmConnBldr.getConnectionNumber()));
deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
commit.get();
- LOG.info("Roadm-connection successfully created: {}-{}-{}", srcTp, destTp, waveNumber);
+ LOG.info("Roadm-connection successfully created: {}-{}-{}-{}", srcTp, destTp,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
return Optional.of(connectionNumber);
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to post {}. Exception: ", rdmConnBldr.build(), e);
}
- public List<Ports> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp)
- throws OpenRoadmInterfaceException {
- String connectionName = generateConnectionNumber(srcTp, destTp, waveNumber);
+ public List<Ports> getConnectionPortTrail(String nodeId, String srcTp, String destTp,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber) throws OpenRoadmInterfaceException {
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber), String.valueOf(higherSpectralSlotNumber));
+ String connectionName = generateConnectionNumber(srcTp, destTp, spectralSlotName);
Optional<MountPoint> mountPointOpt = deviceTransactionManager.getDeviceMountPoint(nodeId);
List<Ports> ports = null;
MountPoint mountPoint;
.child(RoadmConnections.class, new RoadmConnectionsKey(connectionNumber));
}
- private String generateConnectionNumber(String srcTp, String destTp, Long waveNumber) {
- return srcTp + "-" + destTp + "-" + waveNumber;
+ private String generateConnectionNumber(String srcTp, String destTp, String spectralSlotName) {
+ return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, srcTp, destTp, spectralSlotName);
}
public boolean setPowerLevel(String deviceId, OpticalControlMode mode, BigDecimal powerValue, String ctNumber) {
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.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;
Timeouts.DEVICE_READ_TIMEOUT_UNIT);
}
- public Optional<String> postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp) {
- String connectionNumber = generateConnectionName(srcTp, destTp, waveNumber);
+ public Optional<String> postCrossConnect(String deviceId, String srcTp, String destTp,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber) {
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
+ String connectionNumber = generateConnectionName(srcTp, destTp, spectralSlotName);
RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder()
.setConnectionName(connectionNumber)
.setOpticalControlMode(OpticalControlMode.Off)
- .setSource(new SourceBuilder().setSrcIf(srcTp + "-nmc-" + waveNumber).build())
- .setDestination(new DestinationBuilder().setDstIf(destTp + "-nmc-" + waveNumber)
- .build());
+ .setSource(new SourceBuilder()
+ .setSrcIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ srcTp,
+ "nmc",
+ spectralSlotName))
+ .build())
+ .setDestination(new DestinationBuilder()
+ .setDstIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ destTp,
+ "nmc",
+ spectralSlotName))
+ .build());
InstanceIdentifier<RoadmConnections> rdmConnectionIID =
InstanceIdentifier.create(OrgOpenroadmDevice.class)
deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
commit.get();
- LOG.info("Roadm-connection successfully created: {}-{}-{}", srcTp, destTp, waveNumber);
+ LOG.info("Roadm-connection successfully created: {}-{}-{}-{}", srcTp, destTp, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
return Optional.of(connectionNumber);
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to post {}. Exception: ", rdmConnBldr.build(), e);
}
- public List<Ports> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp)
+ public List<Ports> 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<MountPoint> mountPointOpt = deviceTransactionManager.getDeviceMountPoint(nodeId);
List<Ports> ports = null;
MountPoint mountPoint;
new OduConnectionKey(connectionNumber));
}
- private String generateConnectionName(String srcTp, String destTp, Long waveNumber) {
- return srcTp + "-" + destTp + "-" + waveNumber;
+ private String generateConnectionName(String srcTp, String destTp, String spectralSlotName) {
+ return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,srcTp, destTp, spectralSlotName);
}
public Optional<String> postOtnCrossConnect(List<String> createdOduInterfaces, Nodes node) {
WIDTH_40, SLOT_WIDTH_50,
WIDTH_80, SLOT_WIDTH_87_5);
+ public static final int FREQUENCY_PRECISION = 4;
+
+ /**
+ * Map to associate service rate and modulation format to frequency slot width.
+ */
+ public static final Table<Uint32, ModulationFormat, BigDecimal> FREQUENCY_SLOT_WIDTH_TABLE =
+ initFrequencySlotWidthTable();
+ public static final String SPECTRAL_SLOT_SEPARATOR = ":";
+ public static final String NAME_PARAMETERS_SEPARATOR = "-";
+
private GridConstant() {
}
frequencyWidthTable.put(ServiceRateConstant.RATE_400, ModulationFormat.DpQam16, String.valueOf(WIDTH_80));
return frequencyWidthTable;
}
+
+ private static Table<Uint32, ModulationFormat, BigDecimal> initFrequencySlotWidthTable() {
+ Table<Uint32, ModulationFormat, BigDecimal> frequencyWidthTable = HashBasedTable.create();
+ frequencyWidthTable.put(ServiceRateConstant.RATE_100, ModulationFormat.DpQpsk, SLOT_WIDTH_50);
+ frequencyWidthTable.put(ServiceRateConstant.RATE_200, ModulationFormat.DpQpsk, SLOT_WIDTH_87_5);
+ frequencyWidthTable.put(ServiceRateConstant.RATE_300, ModulationFormat.DpQam8, SLOT_WIDTH_87_5);
+ frequencyWidthTable.put(ServiceRateConstant.RATE_400, ModulationFormat.DpQam16, SLOT_WIDTH_87_5);
+ return frequencyWidthTable;
+ }
}
* @param precision int
* @return central frequency in THz with precision
*/
- public static FrequencyTHz getCentralFrequencyWithPrecision(BigDecimal minFrequency,
+ public static org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz
+ getCentralFrequencyWithPrecision(BigDecimal minFrequency,
BigDecimal maxFrequency, int precision) {
- return new FrequencyTHz(computeCentralFrequency(minFrequency, maxFrequency)
- .setScale(precision, RoundingMode.HALF_EVEN));
+ return new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz(
+ computeCentralFrequency(minFrequency, maxFrequency).setScale(precision, RoundingMode.HALF_EVEN));
}
return minFrequency.add(maxFrequency).divide(BigDecimal.valueOf(2));
}
+ /**
+ * Get the lower spectral index for the frequency.
+ * @param frequency BigDecimal
+ * @return the lower spectral index
+ */
+ public static int getLowerSpectralIndexFromFrequency(BigDecimal frequency) {
+ return getIndexFromFrequency(frequency) + 1;
+ }
+
+ /**
+ * Get the higher spectral index for the frequency.
+ * @param frequency BigDecimal
+ * @return the lower spectral index
+ */
+ public static int getHigherSpectralIndexFromFrequency(BigDecimal frequency) {
+ return getIndexFromFrequency(frequency);
+ }
+
}
Mockito.when(rwTransactionMock.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointServiceMock, 3000);
crossConnectImpl121 = new CrossConnectImpl121(deviceTransactionManager);
- Optional<String> res = crossConnectImpl121.postCrossConnect("deviceId", 100L, "srcTp", "destTp");
- Assert.assertEquals(res.get(), "srcTp-destTp-100");
+ Optional<String> res = crossConnectImpl121.postCrossConnect("deviceId", 100L, "srcTp", "destTp", 1, 8);
+ Assert.assertEquals(res.get(), "srcTp-destTp-1:8");
}
// TODO : fix commit
Mockito.when(rwTransactionMock.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointServiceMock, 3000);
crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager);
- Optional res = crossConnectImpl221.postCrossConnect("deviceId", 100L, "srcTp", "destTp");
- Assert.assertEquals(res.get(), "srcTp-destTp-100");
+ Optional res = crossConnectImpl221.postCrossConnect("deviceId", "srcTp", "destTp", 1, 8);
+ Assert.assertEquals(res.get(), "srcTp-destTp-1:8");
}
@Test(expected = NullPointerException.class)
package org.opendaylight.transportpce.common.crossconnect;
import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
@Test
public void postCrossConnect() {
- Optional<?> res = crossConnectImpl.postCrossConnect("100", 100L, "srcTp", "destTp");
+ Optional<?> res = crossConnectImpl.postCrossConnect("100", 100L, "srcTp", "destTp", 1, 8);
Assert.assertFalse("Optional object should be empty",res.isPresent());
String devV121 = "(http://org/openroadm/device?revision=2017-02-06)org-openroadm-device";
when(mappingUtils.getOpenRoadmVersion(any())).thenReturn(devV121);
- when(crossConnectImpl121.postCrossConnect(any(), any(), any(), any()))
+ when(crossConnectImpl121.postCrossConnect(any(), any(), any(), any(), eq(1), eq(8)))
.thenReturn(Optional.of("Value"));
- res = crossConnectImpl.postCrossConnect("100", 100L, "srcTp", "destTp");
+ res = crossConnectImpl.postCrossConnect("100", 100L, "srcTp", "destTp", 1, 8);
Assert.assertTrue("Optional object should have a value",res.isPresent());
}
assertEquals("Index should be 767", 767, GridUtils.getIndexFromFrequency(BigDecimal.valueOf(196.11875)));
assertEquals("Index should be 8", 8, GridUtils.getIndexFromFrequency(BigDecimal.valueOf(191.375)));
assertEquals("Index should be 15", 15, GridUtils.getIndexFromFrequency(BigDecimal.valueOf(191.41875)));
+ assertEquals("Index should be 768", 768, GridUtils.getIndexFromFrequency(BigDecimal.valueOf(196.125)));
}
@Test(expected = IllegalArgumentException.class)
@Test
public void getCentralFrequencyWithPrecisionTest() {
assertEquals("Central frequency should be 191.3500",
- new FrequencyTHz(BigDecimal.valueOf(191.35).setScale(4)),
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz(
+ BigDecimal.valueOf(191.35).setScale(4)),
GridUtils.getCentralFrequencyWithPrecision(BigDecimal.valueOf(191.325),
BigDecimal.valueOf(191.375), 4));
}
@Test
public void getCentralFrequencyWithPrecisionAndRoundTest() {
assertEquals("Central frequency should be 191.3499",
- new FrequencyTHz(BigDecimal.valueOf(191.3499)),
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz(
+ BigDecimal.valueOf(191.3499)),
GridUtils.getCentralFrequencyWithPrecision(BigDecimal.valueOf(191.3244445),
BigDecimal.valueOf(191.3754457788), 4));
}
//TODO Need to Case Optical Power mode/NodeType in case of 2.2 devices
//@SuppressFBwarnings("DM_CONVERT_CASE")
public Boolean setPower(ServicePowerSetupInput input) {
- LOG.info("Olm-setPower initiated");
+ LOG.info("Olm-setPower initiated for input {}", input);
+ int lowerSpectralSlotNumber = input.getLowerSpectralSlotNumber().intValue();
+ int higherSpectralSlotNumber = input.getHigherSpectralSlotNumber().intValue();
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
for (int i = 0; i < input.getNodes().size(); i++) {
String nodeId = input.getNodes().get(i).getNodeId();
String srcTpId = input.getNodes().get(i).getSrcTp();
powerValue = rxSRGPowerRangeMap.get("MaxRx");
}
LOG.info("Calculated Transponder Power value is {}" , powerValue);
- String interfaceName = destTpId + "-" + input.getWaveNumber();
+ String interfaceName = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ destTpId, spectralSlotName);
if (callSetTransponderPower(nodeId, interfaceName, new BigDecimal(powerValue),
openroadmVersion)) {
LOG.info("Transponder OCH connection: {} power updated ", interfaceName);
}
} else {
LOG.info("SRG Power Range not found, setting the Transponder range to default");
- String interfaceName = destTpId + "-" + input.getWaveNumber();
+ String interfaceName = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ destTpId, spectralSlotName);
if (callSetTransponderPower(nodeId, interfaceName, new BigDecimal(-5),
openroadmVersion)) {
LOG.info("Transponder OCH connection: {} power updated ", interfaceName);
}
} else {
LOG.info("Tranponder range not available setting to default power for nodeId: {}", nodeId);
- String interfaceName = destTpId + "-" + input.getWaveNumber();
+ String interfaceName = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ destTpId, spectralSlotName);
if (callSetTransponderPower(nodeId, interfaceName, new BigDecimal(-5),openroadmVersion)) {
LOG.info("Transponder OCH connection: {} power updated ", interfaceName);
try {
Nodes inputNode = inputNodeOptional.get();
OpenroadmVersion openroadmVersion = inputNode.getNodeInfo().getOpenroadmVersion();
LOG.info("This is a roadm {} device", openroadmVersion.getName());
- String connectionNumber = srcTpId + "-" + destTpId + "-" + input.getWaveNumber();
+ String connectionNumber = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,srcTpId, destTpId,
+ spectralSlotName);
LOG.info("Connection number is {}", connectionNumber);
if (destTpId.toLowerCase().contains("deg")) {
Optional<Mapping> mappingObjectOptional = inputNode.nonnullMapping()
* @return true/false based on status of operation
*/
public Boolean powerTurnDown(ServicePowerTurndownInput input) {
- LOG.info("Olm-powerTurnDown initiated");
+ LOG.info("Olm-powerTurnDown initiated for input {}", input);
/*Starting with last element into the list Z -> A for
turning down A -> Z */
+ int lowerSpectralSlotNumber = input.getLowerSpectralSlotNumber().intValue();
+ int higherSpectralSlotNumber = input.getHigherSpectralSlotNumber().intValue();
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
for (int i = input.getNodes().size() - 1; i >= 0; i--) {
String nodeId = input.getNodes().get(i).getNodeId();
String srcTpId = input.getNodes().get(i).getSrcTp();
String destTpId = input.getNodes().get(i).getDestTp();
- Long wlNumber = input.getWaveNumber().toJava();
- String connectionNumber = srcTpId + "-" + destTpId + "-" + wlNumber;
+ String connectionNumber = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,srcTpId, destTpId,
+ spectralSlotName);
if (destTpId.toLowerCase().contains("srg")) {
crossConnect.setPowerLevel(nodeId, OpticalControlMode.Off.getName(), null, connectionNumber);
} else if (destTpId.toLowerCase().contains("deg")) {
nodes.add(node2);
ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768))
+ .build();
return input;
}
nodes.add(node2);
ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768)).build();
return input;
}
nodes.add(node2);
ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768)).build();
return input;
}
nodes.add(node2);
ServicePowerSetupInput input = new ServicePowerSetupInputBuilder().setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768)).build();
return input;
}
ServicePowerTurndownInput input = new ServicePowerTurndownInputBuilder()
.setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768)).build();
return input;
}
ServicePowerTurndownInput input = new ServicePowerTurndownInputBuilder()
.setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768)).build();
return input;
}
ServicePowerTurndownInput input = new ServicePowerTurndownInputBuilder()
.setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768)).build();
return input;
}
ServicePowerTurndownInput input = new ServicePowerTurndownInputBuilder()
.setNodes(nodes)
.setServiceName("service 1")
- .setWaveNumber(Uint32.valueOf("1234")).build();
+ .setWaveNumber(Uint32.valueOf("1"))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768)).build();
return input;
}
import java.util.Iterator;
import java.util.List;
import java.util.Map;
+import java.util.Optional;
import java.util.TreeMap;
import org.opendaylight.transportpce.common.NodeIdPair;
import org.opendaylight.transportpce.common.StringConstants;
+import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.fixedflex.GridUtils;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.OtnServicePathInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.ServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev201125.ServiceImplementationRequestOutputBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.configuration.response.common.ConfigurationResponseCommon;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.configuration.response.common.ConfigurationResponseCommonBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyGHz;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.FrequencyTHz;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceDeleteInput;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201126.PathDescription;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201126.path.description.AToZDirection;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201126.path.description.ZToADirection;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201126.path.description.atoz.direction.AToZ;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201126.path.description.ztoa.direction.ZToA;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev201126.pce.resource.resource.resource.TerminationPoint;
}
public static ServicePowerSetupInput createServicePowerSetupInput(List<Nodes> olmList,
- ServiceImplementationRequestInput input) {
- ServicePowerSetupInputBuilder olmSetupBldr = new ServicePowerSetupInputBuilder()
- .setNodes(olmList);
+ ServiceImplementationRequestInput input) {
+ ServicePowerSetupInputBuilder olmSetupBldr = new ServicePowerSetupInputBuilder().setNodes(olmList);
if (input != null && input.getPathDescription() != null
&& input.getPathDescription().getAToZDirection() != null) {
- olmSetupBldr.setWaveNumber(
- input.getPathDescription().getAToZDirection().getAToZWavelengthNumber());
+ AToZDirection atoZDirection = input.getPathDescription().getAToZDirection();
+ olmSetupBldr.setWaveNumber(atoZDirection.getAToZWavelengthNumber());
+ if (atoZDirection.getAToZMinFrequency() != null) {
+ olmSetupBldr.setLowerSpectralSlotNumber(Uint32
+ .valueOf(GridUtils
+ .getLowerSpectralIndexFromFrequency(atoZDirection.getAToZMinFrequency().getValue())));
+ }
+ if (atoZDirection.getAToZMaxFrequency() != null) {
+ olmSetupBldr.setHigherSpectralSlotNumber(Uint32
+ .valueOf(GridUtils
+ .getHigherSpectralIndexFromFrequency(atoZDirection.getAToZMaxFrequency().getValue())));
+ }
}
return olmSetupBldr.build();
}
public static ServicePathInputData rendererCreateServiceInputAToZ(String serviceName,
PathDescription pathDescription) {
- NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().nonnullAToZ().values().iterator());
+ AToZDirection atoZDirection = pathDescription.getAToZDirection();
+ LOG.info("Building ServicePathInputData for a to z direction {}", atoZDirection);
+ NodeLists nodeLists = getNodesListAToZ(atoZDirection.nonnullAToZ().values().iterator());
ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
.setServiceName(serviceName)
.setOperation(ServicePathInput.Operation.Create)
- .setNodes(nodeLists.getList());
- if (pathDescription.getAToZDirection().getAToZWavelengthNumber() != null) {
+ .setNodes(nodeLists.getList())
+ .setWidth(new FrequencyGHz(GridConstant.WIDTH_40));
+ if (atoZDirection.getAToZWavelengthNumber() != null) {
servicePathInputBuilder
- .setWaveNumber(Uint32.valueOf(pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava()));
+ .setWaveNumber(atoZDirection.getAToZWavelengthNumber());
+ }
+ if (atoZDirection.getAToZMinFrequency() != null) {
+ servicePathInputBuilder.setMinFreq(new FrequencyTHz(atoZDirection.getAToZMinFrequency().getValue()));
+ servicePathInputBuilder.setLowerSpectralSlotNumber(Uint32
+ .valueOf(GridUtils
+ .getLowerSpectralIndexFromFrequency(atoZDirection.getAToZMinFrequency().getValue())));
}
+ if (atoZDirection.getAToZMaxFrequency() != null) {
+ servicePathInputBuilder.setMaxFreq(new FrequencyTHz(atoZDirection.getAToZMaxFrequency().getValue()));
+ servicePathInputBuilder.setHigherSpectralSlotNumber(
+ Uint32.valueOf(GridUtils
+ .getHigherSpectralIndexFromFrequency(atoZDirection.getAToZMaxFrequency().getValue())));
+ }
+ if (atoZDirection.getAToZMinFrequency() != null && atoZDirection.getAToZMaxFrequency() != null) {
+ servicePathInputBuilder.setCenterFreq(
+ GridUtils.getCentralFrequencyWithPrecision(atoZDirection.getAToZMinFrequency().getValue(),
+ atoZDirection.getAToZMaxFrequency().getValue(), GridConstant.FREQUENCY_PRECISION));
+ }
+ if (atoZDirection.getRate() != null && atoZDirection.getModulationFormat() != null) {
+ Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
+ .forName(atoZDirection.getModulationFormat());
+ if (optionalModulationFormat.isPresent()
+ && GridConstant.FREQUENCY_WIDTH_TABLE
+ .contains(atoZDirection.getRate(), optionalModulationFormat.get())) {
+ servicePathInputBuilder
+ .setWidth(FrequencyGHz
+ .getDefaultInstance(GridConstant.FREQUENCY_WIDTH_TABLE.get(atoZDirection.getRate(),
+ optionalModulationFormat.get())));
+ }
+ }
+ servicePathInputBuilder.setModulationFormat(atoZDirection.getModulationFormat());
return new ServicePathInputData(servicePathInputBuilder.build(), nodeLists);
}
public static ServicePathInputData rendererCreateServiceInputZToA(String serviceName,
PathDescription pathDescription) {
+ ZToADirection ztoADirection = pathDescription.getZToADirection();
+ LOG.info("Building ServicePathInputData for z to a direction {}", ztoADirection);
NodeLists nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
.setOperation(ServicePathInput.Operation.Create)
.setServiceName(serviceName)
- .setNodes(nodeLists.getList());
- if (pathDescription.getAToZDirection().getAToZWavelengthNumber() != null) {
+ .setNodes(nodeLists.getList())
+ .setWidth(new FrequencyGHz(GridConstant.WIDTH_40));
+ if (ztoADirection.getZToAWavelengthNumber() != null) {
servicePathInputBuilder
- .setWaveNumber(Uint32.valueOf(pathDescription.getAToZDirection().getAToZWavelengthNumber().toJava()));
+ .setWaveNumber(ztoADirection.getZToAWavelengthNumber());
+ }
+ if (ztoADirection.getZToAMinFrequency() != null) {
+ servicePathInputBuilder.setMinFreq(new FrequencyTHz(ztoADirection.getZToAMinFrequency().getValue()));
+ servicePathInputBuilder.setLowerSpectralSlotNumber(Uint32
+ .valueOf(GridUtils
+ .getLowerSpectralIndexFromFrequency(ztoADirection.getZToAMinFrequency().getValue())));
+ }
+ if (ztoADirection.getZToAMaxFrequency() != null) {
+ servicePathInputBuilder.setMaxFreq(new FrequencyTHz(ztoADirection.getZToAMaxFrequency().getValue()));
+ servicePathInputBuilder.setHigherSpectralSlotNumber(
+ Uint32.valueOf(GridUtils
+ .getHigherSpectralIndexFromFrequency(ztoADirection.getZToAMaxFrequency().getValue())));
+ }
+ if (ztoADirection.getZToAMinFrequency() != null && ztoADirection.getZToAMaxFrequency() != null) {
+ servicePathInputBuilder.setCenterFreq(
+ GridUtils.getCentralFrequencyWithPrecision(ztoADirection.getZToAMinFrequency().getValue(),
+ ztoADirection.getZToAMaxFrequency().getValue(), GridConstant.FREQUENCY_PRECISION));
+ }
+ if (ztoADirection.getRate() != null && ztoADirection.getModulationFormat() != null) {
+ Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
+ .forName(ztoADirection.getModulationFormat());
+ if (optionalModulationFormat.isPresent()
+ && GridConstant.FREQUENCY_WIDTH_TABLE
+ .contains(ztoADirection.getRate(), optionalModulationFormat.get())) {
+ servicePathInputBuilder.setWidth(FrequencyGHz
+ .getDefaultInstance(GridConstant.FREQUENCY_WIDTH_TABLE.get(ztoADirection.getRate(),
+ optionalModulationFormat.get())));
+ }
}
+ servicePathInputBuilder.setModulationFormat(ztoADirection.getModulationFormat());
return new ServicePathInputData(servicePathInputBuilder.build(), nodeLists);
}
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.fixedflex.GridConstant;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
* @param nodeId node ID
* @param logicalConnPoint logical connection point
* @param waveNumber wavelength number of the OCH interface.
- *
+ * @param lowerSpectralSlotNumber int
+ * @param higherSpectralSlotNumber int
* @return Name of the interface if successful, otherwise return null.
*
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
- public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber)
+ public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
-
Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
throw new OpenRoadmInterfaceException(String.format(
"Unable to get mapping from PortMapping for node %s and logical connection port %s",
nodeId, logicalConnPoint));
}
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
// Create generic interface
InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
- createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
+ createOpenRoadmOchInterfaceName(logicalConnPoint, spectralSlotName));
// OCH interface specific data
OchBuilder ocIfBuilder = new OchBuilder().setWavelengthNumber(Uint32.valueOf(waveNumber));
}
public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- OchAttributes.ModulationFormat format) throws OpenRoadmInterfaceException {
+ OchAttributes.ModulationFormat format, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ throws OpenRoadmInterfaceException {
Mapping portMap = this.portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
throw new OpenRoadmInterfaceException(String.format(
"Unable to get mapping from PortMapping for node %s and logical connection port %s",
nodeId, logicalConnPoint));
}
-
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
// OCH interface specific data
OchBuilder ocIfBuilder = new OchBuilder()
.setWavelengthNumber(Uint32.valueOf(waveNumber))
.interfaces.rev161014.Interface1Builder();
// Create generic interface
InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
- createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
+ createOpenRoadmOchInterfaceName(logicalConnPoint, spectralSlotName));
ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
// Post interface on the device
return ochInterfaceBldr.getName();
}
- public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) {
- return logicalConnectionPoint + "-" + waveNumber;
+ public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
+ return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
}
public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+
public class OpenRoadmInterface221 {
private static final String MAPPING_ERROR_EXCEPTION_MESSAGE =
"Unable to get mapping from PortMapping for node % and logical connection port %s";
return ethInterfaceBldr.getName();
}
- public List<String> createFlexOCH(String nodeId, String logicalConnPoint, Long bitmapIndex,
- BigDecimal centerFreq, BigDecimal width)
+ public List<String> createFlexOCH(String nodeId, String logicalConnPoint, BigDecimal centerFreq,
+ BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
List<String> interfacesCreated = new ArrayList<>();
if (logicalConnPoint.contains("DEG")) {
- String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, centerFreq, width, bitmapIndex);
+ String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, centerFreq, width,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
interfacesCreated.add(mcInterfaceCreated);
}
- String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, centerFreq, width, bitmapIndex);
+ String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, centerFreq, width,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
interfacesCreated.add(mcInterfaceCreated);
return interfacesCreated;
}
* @param nodeId node ID
* @param logicalConnPoint logical connection point
* @param waveNumber wavelength number of the OCH interface.
- *
+ * @param lowerSpectralSlotNumber int
+ * @param higherSpectralSlotNumber int
* @return Name of the interface if successful, otherwise return null.
*
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
- public List<String> createFlexOCH(String nodeId, String logicalConnPoint, Long waveNumber)
+ public List<String> createFlexOCH(String nodeId, String logicalConnPoint, Long waveNumber,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
List<String> interfacesCreated = new ArrayList<>();
if (logicalConnPoint.contains("DEG")) {
- String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, waveNumber);
+ String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, waveNumber,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
interfacesCreated.add(mcInterfaceCreated);
}
- String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, waveNumber);
+ String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, waveNumber,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
interfacesCreated.add(nmcInterfaceCreated);
return interfacesCreated;
}
- public String createMCInterface(String nodeId, String logicalConnPoint, Long waveNumber)
+ public String createMCInterface(String nodeId, String logicalConnPoint, Long waveNumber,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
// TODO : Check this method
}
// TODO : Check this method
-
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
- MediaChannelTrailTerminationPoint.class, logicalConnPoint + "-mc" + "-" + waveNumber)
+ MediaChannelTrailTerminationPoint.class, String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ logicalConnPoint,"mc",
+ spectralSlotName))
.setSupportingInterface(portMap.getSupportingOms());
McTtpBuilder mcTtpBuilder = new McTtpBuilder()
}
public String createMCInterface(String nodeId, String logicalConnPoint,
- BigDecimal centerFrequency, BigDecimal width, Long bitmapIndex)
+ BigDecimal centerFrequency, BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
// TODO : Check this method
throw new OpenRoadmInterfaceException(
String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
}
-
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
// TODO : Check this method
LOG.info("MC interface Freq Start {} and Freq End {} and center-Freq {}",
flexGrid.getStart(), flexGrid.getStop(), centerFrequency);
InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
- MediaChannelTrailTerminationPoint.class, logicalConnPoint + "-mc" + "-" + bitmapIndex)
+ MediaChannelTrailTerminationPoint.class, String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ logicalConnPoint, "mc", spectralSlotName))
.setSupportingInterface(portMap.getSupportingOms());
McTtpBuilder mcTtpBuilder = new McTtpBuilder()
return mcInterfaceBldr.getName();
}
- public String createNMCInterface(String nodeId, String logicalConnPoint, Long waveNumber)
+ public String createNMCInterface(String nodeId, String logicalConnPoint, Long waveNumber,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
// TODO : Check this method
throw new OpenRoadmInterfaceException(
String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
}
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
LOG.info("Freq Start {} and Freq End {} and center-Freq {}",
fixedFlex.getStart(), fixedFlex.getStop(), fixedFlex.getCenterFrequency());
//TODO : Check this method
InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
- NetworkMediaChannelConnectionTerminationPoint.class, logicalConnPoint + "-nmc" + "-" + waveNumber);
+ NetworkMediaChannelConnectionTerminationPoint.class, String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ logicalConnPoint, "nmc", spectralSlotName));
if (logicalConnPoint.contains("DEG")) {
- nmcInterfaceBldr.setSupportingInterface(logicalConnPoint + "-mc" + "-" + waveNumber);
+ nmcInterfaceBldr.setSupportingInterface(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
+ logicalConnPoint, "mc", spectralSlotName));
}
NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
}
public String createNMCInterface(String nodeId, String logicalConnPoint,
- BigDecimal centerFrequency, BigDecimal width, Long bitmapIndex)
+ BigDecimal centerFrequency, BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
LOG.info("This is the central frequency {}", centerFrequency.floatValue());
LOG.info("This is the nmc width {}", width.floatValue());
throw new OpenRoadmInterfaceException(
String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
}
-
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
//TODO : Check this method
+ String nmcName = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnPoint, "nmc",
+ spectralSlotName);
InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
- NetworkMediaChannelConnectionTerminationPoint.class, logicalConnPoint + "-nmc" + "-" + bitmapIndex);
+ NetworkMediaChannelConnectionTerminationPoint.class, nmcName);
if (logicalConnPoint.contains("DEG")) {
- nmcInterfaceBldr.setSupportingInterface(logicalConnPoint + "-mc" + "-" + bitmapIndex);
+ nmcInterfaceBldr.setSupportingInterface(nmcName);
}
NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
return nmcInterfaceBldr.getName();
}
- public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber)
+ public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
// TODO : Check this method
// TODO: Check if this the correct way to set modulation format here
.setModulationFormat(ModulationFormat.DpQpsk)
.setTransmitPower(new PowerDBm(new BigDecimal("-5")));
-
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
// Create generic interface
InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
- createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
+ createOpenRoadmOchInterfaceName(logicalConnPoint, spectralSlotName));
// Create Interface1 type object required for adding as augmentation
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
}
public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
- Long waveNumber, BigDecimal centerFrequency, BigDecimal slotWidth)
+ BigDecimal centerFrequency, int lowerSpectralSlotNumber, int higherSpectralSlotNumber, String format)
throws OpenRoadmInterfaceException {
// TODO : Check this method
-
+ if (centerFrequency == null) {
+ LOG.error("Center frequency cannot be null");
+ throw new OpenRoadmInterfaceException("Center frequency cannot be null");
+ }
+ ModulationFormat modulationFormat = ModulationFormat.DpQpsk;
+ Optional<ModulationFormat> optionalModulationFormat = ModulationFormat.forName(format);
+ if (optionalModulationFormat.isPresent()) {
+ modulationFormat = optionalModulationFormat.get();
+ }
// OCH interface specific data
OchBuilder ocIfBuilder = new OchBuilder()
.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)))
.setRate(R100G.class)
.setTransmitPower(new PowerDBm(new BigDecimal("-5")))
- .setModulationFormat(ModulationFormat.DpQpsk);
-
- // In Flex-grid, slot-width could be other than 50 GHz
- if ((centerFrequency != null) && (slotWidth != null)) {
- ocIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)));
- ocIfBuilder.setWidth(FrequencyGHz.getDefaultInstance(String.valueOf(slotWidth)));
- }
- else {
- // Use fixed grid to find the
- fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
- ocIfBuilder.setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())));
- }
+ .setModulationFormat(modulationFormat);
Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
throw new OpenRoadmInterfaceException(
String.format("Unable to get mapping from PortMapping for node %s and logical connection port %s",
nodeId, logicalConnPoint));
}
-
-
-
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
// Create generic interface
InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
- createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
+ createOpenRoadmOchInterfaceName(logicalConnPoint, spectralSlotName));
// Create Interface1 type object required for adding as augmentation
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1Builder
}
- public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) {
- return logicalConnectionPoint + "-" + waveNumber;
+ public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotName) {
+ return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotName);
}
private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
import java.util.List;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.fixedflex.GridConstant;
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.rev201012.network.nodes.Mapping;
}
public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- BigDecimal centerFreq, BigDecimal width)
+ BigDecimal centerFreq, BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
+ return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber,
- centerFreq, width);
+ return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, centerFreq,
+ width, lowerSpectralSlotNumber, higherSpectralSlotNumber);
default:
return null;
}
* @param nodeId node ID
* @param logicalConnPoint logical connection point
* @param waveNumber wavelength number of the OCH interface.
+ * @param lowerSpectralSlotNumber int
+ * @param higherSpectralSlotNumber int
* @return Name of the interface if successful, otherwise return null.
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
- public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber)
+ public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
+ return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber);
+ return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
default:
return null;
}
}
public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- OchAttributes.ModulationFormat format, BigDecimal centerFreq, BigDecimal width)
+ OchAttributes.ModulationFormat format, BigDecimal centerFreq, int lowerSpectralSlotNumber,
+ int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format);
+ return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
- centerFreq, width);
+ return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, centerFreq,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber, format.getName());
default:
return null;
}
}
public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- OchAttributes.ModulationFormat format)
+ OchAttributes.ModulationFormat format, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format);
+ return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber, format,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber);
+ return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber);
default:
return null;
}
}
}
- public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, Long waveNumber) {
- return logicalConnectionPoint + "-" + waveNumber;
+ public String createOpenRoadmOchInterfaceName(String logicalConnectionPoint, String spectralSlotNumber) {
+ return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,logicalConnectionPoint, spectralSlotNumber);
}
public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.fixedflex.GridConstant;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
@Override
public ServicePathOutput setupServicePath(ServicePathInput input, ServicePathDirection direction) {
+ LOG.info("setup service path for input {} and direction {}", input, direction);
List<Nodes> nodes = new ArrayList<>();
if (input.getNodes() != null) {
nodes.addAll(input.getNodes());
try {
// if the node is currently mounted then proceed
if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
- // TODO: In the case of flex-grid, the wave-number becomes bitmap index
- // TODO: need to update transportpce-common-types accordingly, to a more, generic-term
+ int lowerSpectralSlotNumber = input.getLowerSpectralSlotNumber().intValue();
+ int higherSpectralSlotNumber = input.getHigherSpectralSlotNumber().intValue();
+ ModulationFormat modulationFormat = ModulationFormat.DpQpsk;
+ if (input.getModulationFormat() != null
+ && ModulationFormat.forName(input.getModulationFormat()).isPresent()) {
+ modulationFormat = ModulationFormat.forName(input.getModulationFormat()).get();
+ }
Long waveNumber = input.getWaveNumber().toJava();
BigDecimal centerFreq = null;
BigDecimal width = null;
String srcTp = node.getSrcTp();
String destTp = node.getDestTp();
if ((destTp != null) && destTp.contains(StringConstants.NETWORK_TOKEN)) {
+ LOG.info("Adding supporting OCH interface for node {}, dest tp {}, wave number {},"
+ + "center freq {}, slot width {}, lower spectral number {},"
+ + "higher spectral number {}",
+ nodeId, destTp, waveNumber, centerFreq, width, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
crossConnectFlag++;
String supportingOchInterface;
if ((centerFreq != null) && (width != null)) {
supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, destTp, waveNumber, ModulationFormat.DpQpsk, centerFreq, width);
+ nodeId, destTp, waveNumber, modulationFormat, centerFreq, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
}
else {
supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, destTp, waveNumber, ModulationFormat.DpQpsk);
+ nodeId, destTp, waveNumber, modulationFormat, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
}
createdOchInterfaces.add(supportingOchInterface);
// Here we pass logical connection-point of z-end to set SAPI and DAPI
}
}
if ((srcTp != null) && srcTp.contains(StringConstants.CLIENT_TOKEN)) {
+ LOG.info("Adding supporting EThernet interface for node {}, src tp {}", nodeId, srcTp);
crossConnectFlag++;
// create OpenRoadm Xponder Client Interfaces
createdEthInterfaces.add(
this.openRoadmInterfaceFactory.createOpenRoadmEthInterface(nodeId, srcTp));
}
if ((srcTp != null) && srcTp.contains(StringConstants.NETWORK_TOKEN)) {
+ LOG.info("Adding supporting OCH interface for node {}, src tp {}, wave number {},"
+ + "center freq {}, slot width {}, lower spectral number {},"
+ + "higher spectral number {}",
+ nodeId, srcTp, waveNumber, centerFreq, width, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
crossConnectFlag++;
// create OpenRoadm Xponder Line Interfaces
String supportingOchInterface;
if ((centerFreq != null) && (width != null)) {
supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, srcTp, waveNumber, ModulationFormat.DpQpsk, centerFreq, width);
+ nodeId, srcTp, waveNumber, modulationFormat, centerFreq, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
}
else {
supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, srcTp, waveNumber, ModulationFormat.DpQpsk);
+ nodeId, srcTp, waveNumber,modulationFormat, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
}
createdOchInterfaces.add(supportingOchInterface);
String supportingOtuInterface = this.openRoadmInterfaceFactory
}
}
if ((destTp != null) && destTp.contains(StringConstants.CLIENT_TOKEN)) {
+ LOG.info("Adding supporting EThernet interface for node {}, dest tp {}", nodeId, destTp);
crossConnectFlag++;
// create OpenRoadm Xponder Client Interfaces
createdEthInterfaces.add(
}
if ((srcTp != null) && (srcTp.contains(StringConstants.TTP_TOKEN)
|| srcTp.contains(StringConstants.PP_TOKEN))) {
+ LOG.info("Adding supporting OCH interface for node {}, src tp {}, wave number {},"
+ + "center freq {}, slot width {}, lower spectral number {},"
+ + "higher spectral number {}",
+ nodeId, srcTp, waveNumber, centerFreq, width, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
if ((centerFreq != null) && (width != null)) {
createdOchInterfaces.addAll(
this.openRoadmInterfaceFactory
- .createOpenRoadmOchInterface(nodeId, srcTp, waveNumber, centerFreq, width));
+ .createOpenRoadmOchInterface(nodeId, srcTp, waveNumber, centerFreq, width,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber));
}
else {
createdOchInterfaces.addAll(
this.openRoadmInterfaceFactory
- .createOpenRoadmOchInterface(nodeId, srcTp, waveNumber));
+ .createOpenRoadmOchInterface(nodeId, srcTp, waveNumber, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber));
}
}
if ((destTp != null) && (destTp.contains(StringConstants.TTP_TOKEN)
|| destTp.contains(StringConstants.PP_TOKEN))) {
-
+ LOG.info("Adding supporting OCH interface for node {}, dest tp {}, wave number {},"
+ + "center freq {}, slot width {}, lower spectral number {},"
+ + "higher spectral number {}",
+ nodeId, destTp, waveNumber, centerFreq, width, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
if ((centerFreq != null) && (width != null)) {
createdOchInterfaces.addAll(
this.openRoadmInterfaceFactory
- .createOpenRoadmOchInterface(nodeId, destTp, waveNumber, centerFreq, width));
+ .createOpenRoadmOchInterface(nodeId, destTp, waveNumber, centerFreq, width,
+ lowerSpectralSlotNumber, higherSpectralSlotNumber));
}
else {
createdOchInterfaces.addAll(
this.openRoadmInterfaceFactory
- .createOpenRoadmOchInterface(nodeId, destTp, waveNumber));
+ .createOpenRoadmOchInterface(nodeId, destTp, waveNumber, lowerSpectralSlotNumber,
+ higherSpectralSlotNumber));
}
}
LOG.info("Creating cross connect between source {} and destination {} for node {}", srcTp,
destTp, nodeId);
Optional<String> connectionNameOpt =
- this.crossConnect.postCrossConnect(nodeId, waveNumber, srcTp, destTp);
+ this.crossConnect.postCrossConnect(nodeId, waveNumber, srcTp, destTp,
+ lowerSpectralSlotNumber,
+ higherSpectralSlotNumber);
if (connectionNameOpt.isPresent()) {
nodesProvisioned.add(nodeId);
createdConnections.add(connectionNameOpt.get());
}
// if the node is currently mounted then proceed.
if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
- interfacesToDelete.addAll(getInterfaces2delete(nodeId, srcTp, destTp, waveNumber));
+ interfacesToDelete.addAll(getInterfaces2delete(nodeId, srcTp, destTp, waveNumber,
+ input.getLowerSpectralSlotNumber().intValue(),
+ input.getHigherSpectralSlotNumber().intValue()));
} else {
String result = nodeId + IS_NOT_MOUNTED_ON_THE_CONTROLLER;
results.add(result);
}
private List<String> getInterfaces2delete(
- String nodeId, String srcTp, String destTp, Long waveNumber) {
+ String nodeId, String srcTp, String destTp, Long waveNumber,
+ int lowerSpectralSlotNumber, int higherSpectralSlotNumber) {
+ String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
List<String> interfacesToDelete = new LinkedList<>();
if (destTp.contains(StringConstants.NETWORK_TOKEN)
|| srcTp.contains(StringConstants.CLIENT_TOKEN)
}
interfacesToDelete.add(destTp + "-OTU");
interfacesToDelete.add(
- this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(destTp, waveNumber));
+ this.openRoadmInterfaceFactory
+ .createOpenRoadmOchInterfaceName(destTp,spectralSlotName));
}
if (srcTp.contains(StringConstants.NETWORK_TOKEN)) {
interfacesToDelete.add(srcTp + "-ODU");
interfacesToDelete.add(srcTp + "-OTU");
interfacesToDelete
- .add(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaceName(srcTp, waveNumber));
+ .add(this.openRoadmInterfaceFactory
+ .createOpenRoadmOchInterfaceName(srcTp,spectralSlotName));
}
if (srcTp.contains(StringConstants.CLIENT_TOKEN)) {
interfacesToDelete.add(srcTp + "-ETHERNET");
interfacesToDelete.add(destTp + "-ETHERNET");
}
} else {
- String connectionNumber = srcTp + "-" + destTp + "-" + waveNumber;
+ String connectionNumber = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, srcTp, destTp,
+ spectralSlotName);
List<String> intToDelete = this.crossConnect.deleteCrossConnect(nodeId, connectionNumber, false);
- connectionNumber = destTp + "-" + srcTp + "-" + waveNumber;
+ connectionNumber = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, destTp, srcTp, spectralSlotName);
if (intToDelete != null) {
for (String interf : intToDelete) {
if (!this.openRoadmInterfaceFactory.isUsedByXc(nodeId, interf, connectionNumber,
Mockito.when(fixedFlex.getStart()).thenReturn(12d);
Mockito.when(fixedFlex.getStop()).thenReturn(12d);
Mockito.when(fixedFlex.getCenterFrequency()).thenReturn(12d);
- Long waveNumber = 1000L;
- Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber));
- Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber),
- Arrays.asList(logicalConnPoint + "-nmc-" + waveNumber));
+ Long waveNumber = 1L;
+ Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber, 761, 768));
+ Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber, 761, 768),
+ Arrays.asList(logicalConnPoint + "-nmc-761:768"));
}
@Test
Mockito.when(fixedFlex.getStart()).thenReturn(12d);
Mockito.when(fixedFlex.getStop()).thenReturn(12d);
Mockito.when(fixedFlex.getCenterFrequency()).thenReturn(12d);
- Long waveNumber = 1000L;
- Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber));
- Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber),
- Arrays.asList(logicalConnPoint + "-mc-" + waveNumber, logicalConnPoint + "-nmc-" + waveNumber));
+ Long waveNumber = 1L;
+ Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber, 761, 768));
+ Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber, 761, 768),
+ Arrays.asList(logicalConnPoint + "-mc-" + waveNumber, logicalConnPoint + "-nmc-761:768"));
}
@Test
.thenReturn(new MappingBuilder().setLogicalConnectionPoint(logicalConnPoint).build());
Mockito.when(fixedFlex.getCenterFrequency()).thenReturn(12d);
Mockito.when(fixedFlex.getFixedFlexWaveMapping(Mockito.anyLong())).thenReturn(new FixedFlexImpl());
- Long waveNumber = 1000L;
- Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber),
- logicalConnPoint + "-" + waveNumber);
+ Long waveNumber = 1L;
+ Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
+ 761, 768), logicalConnPoint + "-761:768");
}
@Test
public void testCreateOpenRoadmOchInterfaceName() {
String logicalConnPoint = "logicalConnPoint";
- Long waveNumber = 1000L;
- Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber),
- logicalConnPoint + "-" + waveNumber);
+ Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterfaceName(logicalConnPoint, "761:768"),
+ logicalConnPoint + "-761:768");
}
time.sleep(2)
def test_13_check_xc1_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
+ 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768',
'wavelength-number': 1,
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-1'},
+ {'src-if': 'SRG1-PP1-TXRX-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-1'},
+ {'dst-if': 'DEG1-TTP-TXRX-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(5)
def test_14_check_xc1_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
+ 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768',
'wavelength-number': 1,
'opticalControlMode': 'gainLoss',
'target-output-power': 2.0
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-1'},
+ {'src-if': 'SRG1-PP1-TXRX-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-1'},
+ {'dst-if': 'DEG2-TTP-TXRX-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(5)
time.sleep(1)
def test_24_check_xc2_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-2")
+ response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP2-TXRX-753:760")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-2',
+ 'connection-number': 'DEG1-TTP-TXRX-SRG1-PP2-TXRX-753:760',
'wavelength-number': 2,
'opticalControlMode': 'power'
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'DEG1-TTP-TXRX-2'},
+ {'src-if': 'DEG1-TTP-TXRX-753:760'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'SRG1-PP2-TXRX-2'},
+ {'dst-if': 'SRG1-PP2-TXRX-753:760'},
res['roadm-connections'][0]['destination'])
def test_25_check_topo_XPDRA(self):
time.sleep(1)
def test_38_check_xc1_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
+ 'connection-number': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768',
'wavelength-number': 1,
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-1'},
+ {'src-if': 'SRG1-PP1-TXRX-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-1'},
+ {'dst-if': 'DEG1-TTP-TXRX-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(7)
def test_39_check_xc1_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
+ 'connection-number': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768',
'wavelength-number': 1,
'opticalControlMode': 'gainLoss',
'target-output-power': 2.0
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-1'},
+ {'src-if': 'SRG1-PP1-TXRX-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-1'},
+ {'dst-if': 'DEG2-TTP-TXRX-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(7)
time.sleep(2)
def test_42_check_xc2_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-2")
+ response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP2-TXRX-DEG1-TTP-TXRX-753:760")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-2',
+ 'connection-number': 'SRG1-PP2-TXRX-DEG1-TTP-TXRX-753:760',
'wavelength-number': 2,
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP2-TXRX-2'},
+ {'src-if': 'SRG1-PP2-TXRX-753:760'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-2'},
+ {'dst-if': 'DEG1-TTP-TXRX-753:760'},
res['roadm-connections'][0]['destination'])
time.sleep(2)
{"node-id": "ROADMC01",
"dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG2-TTP-TXRX"},
{"node-id": "XPDRC01",
- "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}])
+ "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
{"node-id": "ROADMA01",
"src-tp": "DEG1-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
{"node-id": "XPDRA01",
- "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}])
+ "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
"src-tp": "XPDR1-NETWORK1",
"node-id": "XPDRC01"
}
- ]
+ ],
+ "center-freq": 196.1,
+ "width": 40,
+ "min-freq": 196.075,
+ "max-freq": 196.125,
+ "lower-spectral-slot-number": 761,
+ "higher-spectral-slot-number": 768
}
}
response = test_utils.post_request(url, data)
def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
response = test_utils.check_netconf_node_request(
"XPDRA01",
- "interface/XPDR1-NETWORK1-1/org-openroadm-optical-channel-interfaces:och")
+ "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
def test_21_get_roadmconnection_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(-3.3, res['roadm-connections'][0]['target-output-power'])
def test_22_get_roadmconnection_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
"dest-tp": "XPDR1-CLIENT1",
"node-id": "XPDRA01"
}
- ]
+ ],
+ "center-freq": 196.1,
+ "width": 40,
+ "min-freq": 196.075,
+ "max-freq": 196.125,
+ "lower-spectral-slot-number": 761,
+ "higher-spectral-slot-number": 768
}
}
response = test_utils.post_request(url, data)
def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
response = test_utils.check_netconf_node_request(
"XPDRC01",
- "interface/XPDR1-NETWORK1-1/org-openroadm-optical-channel-interfaces:och")
+ "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(0, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
self.assertEqual(1, res['org-openroadm-optical-channel-interfaces:och']['wavelength-number'])
def test_25_get_roadmconnection_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
"src-tp": "XPDR1-NETWORK1",
"node-id": "XPDRC01"
}
- ]
+ ],
+ "center-freq": 196.1,
+ "width": 40,
+ "min-freq": 196.075,
+ "max-freq": 196.125,
+ "lower-spectral-slot-number": 761,
+ "higher-spectral-slot-number": 768
}
}
response = test_utils.post_request(url, data)
+ print(response.json())
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Success', res["output"]["result"])
def test_27_get_roadmconnection_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(-60, res['roadm-connections'][0]['target-output-power'])
def test_28_get_roadmconnection_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADMC01", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP1-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
{"node-id": "ROADMC01",
"dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG2-TTP-TXRX"},
{"node-id": "XPDRC01",
- "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}])
+ "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
{"node-id": "ROADMA01",
"src-tp": "DEG1-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
{"node-id": "XPDRA01",
- "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}])
+ "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
[{"node-id": "XPDRA01",
"dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
{"node-id": "ROADMA01",
- "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}])
+ "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
+ 196.05, 40, 196.025, 196.075, 753,
+ 760)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
response = test_utils.check_netconf_node_request(
"XPDRA01",
- "interface/XPDR1-NETWORK2-2/org-openroadm-optical-channel-interfaces:och")
+ "interface/XPDR1-NETWORK2-753:760/org-openroadm-optical-channel-interfaces:och")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
[{"node-id": "XPDRA01",
"dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
{"node-id": "ROADMA01",
- "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}])
+ "dest-tp": "DEG1-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
"renderer:dest-tp": "DEG1-TTP-TXRX"},
{"renderer:node-id": "XPDRA01",
"renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}])
+ "renderer:dest-tp": "XPDR1-NETWORK1"}],
+ 195.8, 40, 195.775, 195.825, 713,
+ 720)
+ print(response.json())
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes: ROADMA01', res["output"]["result"])
def test_06_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "interface/DEG1-TTP-TXRX-7")
+ response = test_utils.check_netconf_node_request("ROADMA01", "interface/DEG1-TTP-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'name': 'DEG1-TTP-TXRX-7',
+ 'name': 'DEG1-TTP-TXRX-713:720',
'administrative-state': 'inService',
'supporting-circuit-pack-name': '2/0',
'type': 'org-openroadm-interfaces:opticalChannel',
res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_07_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "interface/SRG1-PP7-TXRX-7")
+ response = test_utils.check_netconf_node_request("ROADMA01", "interface/SRG1-PP7-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'name': 'SRG1-PP7-TXRX-7',
+ 'name': 'SRG1-PP7-TXRX-713:720',
'administrative-state': 'inService',
'supporting-circuit-pack-name': '4/0',
'type': 'org-openroadm-interfaces:opticalChannel',
res['interface'][0]['org-openroadm-optical-channel-interfaces:och'])
def test_08_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-7")
+ response = test_utils.check_netconf_node_request(
+ "ROADMA01", "roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-number': 'SRG1-PP7-TXRX-DEG1-TTP-TXRX-7',
+ 'connection-number': 'SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720',
'wavelength-number': 7,
'opticalControlMode': 'off'
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP7-TXRX-7'},
+ {'src-if': 'SRG1-PP7-TXRX-713:720'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-7'},
+ {'dst-if': 'DEG1-TTP-TXRX-713:720'},
res['roadm-connections'][0]['destination'])
def test_09_service_path_create_xpdr_check(self):
- response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-7")
+ response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'name': 'XPDR1-NETWORK1-7',
+ 'name': 'XPDR1-NETWORK1-713:720',
'administrative-state': 'inService',
'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
'type': 'org-openroadm-interfaces:opticalChannel',
'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
'type': 'org-openroadm-interfaces:otnOtu',
'supporting-port': '1',
- 'supporting-interface': 'XPDR1-NETWORK1-7'
+ 'supporting-interface': 'XPDR1-NETWORK1-713:720'
}, **res['interface'][0]),
res['interface'][0]
)
"renderer:dest-tp": "DEG1-TTP-TXRX"},
{"renderer:node-id": "XPDRA01",
"renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}])
+ "renderer:dest-tp": "XPDR1-NETWORK1"}],
+ 195.8, 40, 195.775, 195.825, 713,
+ 720)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json(), {
'output': {'result': 'Request processed', 'success': True}})
def test_15_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "interface/DEG1-TTP-TXRX-7")
+ response = test_utils.check_netconf_node_request("ROADMA01", "interface/DEG1-TTP-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn(
res['errors']['error'])
def test_16_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "interface/SRG1-PP7-TXRX-7")
+ response = test_utils.check_netconf_node_request("ROADMA01", "interface/SRG1-PP7-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn(
res['errors']['error'])
def test_17_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-7")
+ response = test_utils.check_netconf_node_request("ROADMA01", "roadm-connections/SRG1-PP7-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn(
res['errors']['error'])
def test_18_service_path_delete_xpdr_check(self):
- response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-7")
+ response = test_utils.check_netconf_node_request("XPDRA01", "interface/XPDR1-NETWORK1-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn(
time.sleep(2)
def test_13_check_xc1_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
+ 'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768',
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ {'src-if': 'SRG1-PP1-TXRX-nmc-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
+ {'dst-if': 'DEG2-TTP-TXRX-nmc-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(5)
def test_14_check_xc1_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
+ 'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768',
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ {'src-if': 'SRG1-PP1-TXRX-nmc-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
+ {'dst-if': 'DEG1-TTP-TXRX-nmc-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(5)
time.sleep(1)
def test_24_check_xc2_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP2-TXRX-2")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/DEG2-TTP-TXRX-SRG1-PP2-TXRX-753:760")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-2',
+ 'connection-name': 'DEG2-TTP-TXRX-SRG1-PP2-TXRX-753:760',
'opticalControlMode': 'power'
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'DEG2-TTP-TXRX-nmc-2'},
+ {'src-if': 'DEG2-TTP-TXRX-nmc-753:760'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'SRG1-PP2-TXRX-nmc-2'},
+ {'dst-if': 'SRG1-PP2-TXRX-nmc-753:760'},
res['roadm-connections'][0]['destination'])
def test_25_check_topo_XPDRA(self):
time.sleep(1)
def test_38_check_xc1_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-1',
+ 'connection-name': 'SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768',
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ {'src-if': 'SRG1-PP1-TXRX-nmc-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-nmc-1'},
+ {'dst-if': 'DEG2-TTP-TXRX-nmc-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(7)
def test_39_check_xc1_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-1',
+ 'connection-name': 'SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768',
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP1-TXRX-nmc-1'},
+ {'src-if': 'SRG1-PP1-TXRX-nmc-761:768'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-nmc-1'},
+ {'dst-if': 'DEG1-TTP-TXRX-nmc-761:768'},
res['roadm-connections'][0]['destination'])
time.sleep(7)
time.sleep(2)
def test_42_check_xc2_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP2-TXRX-DEG2-TTP-TXRX-2")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP2-TXRX-DEG2-TTP-TXRX-753:760")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-2',
+ 'connection-name': 'SRG1-PP2-TXRX-DEG2-TTP-TXRX-753:760',
'opticalControlMode': 'gainLoss',
'target-output-power': -3.0
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP2-TXRX-nmc-2'},
+ {'src-if': 'SRG1-PP2-TXRX-nmc-753:760'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG2-TTP-TXRX-nmc-2'},
+ {'dst-if': 'DEG2-TTP-TXRX-nmc-753:760'},
res['roadm-connections'][0]['destination'])
time.sleep(2)
"transportpce-device-renderer:src-tp": "SRG1-PP1-TXRX",
"transportpce-device-renderer:dest-tp": "DEG1-TTP-TXRX"
}
- ]
+ ],
+ "transportpce-device-renderer:min-freq": 196.95625,
+ "transportpce-device-renderer:max-freq": 196.04375,
+ "transportpce-device-renderer:lower-spectral-slot-number": 741,
+ "transportpce-device-renderer:higher-spectral-slot-number": 754
}
}
url = test_utils.RESTCONF_BASE_URL + \
# Get Degree MC interface and check
def test_08_degree_mc_interface(self):
response = test_utils.check_netconf_node_request("ROADM-D1",
- "interface/DEG1-TTP-TXRX-mc-2")
+ "interface/DEG1-TTP-TXRX-mc-741:754")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictEqual(
- dict({"name": "DEG1-TTP-TXRX-mc-2",
+ dict({"name": "DEG1-TTP-TXRX-mc-741:754",
"supporting-interface": "OMS-DEG1-TTP-TXRX",
"supporting-circuit-pack-name": "1/0",
"circuit-id": "TBD",
# get DEG-NMC interface and check
def test_09_degree_nmc_interface(self):
response = test_utils.check_netconf_node_request("ROADM-D1",
- "interface/DEG1-TTP-TXRX-nmc-2")
+ "interface/DEG1-TTP-TXRX-nmc-741:754")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictEqual(
- dict({"name": "DEG1-TTP-TXRX-nmc-2",
- "supporting-interface": "DEG1-TTP-TXRX-mc-2",
+ dict({"name": "DEG1-TTP-TXRX-nmc-741:754",
+ "supporting-interface": "DEG1-TTP-TXRX-mc-741:754",
"supporting-circuit-pack-name": "1/0",
"circuit-id": "TBD",
"description": "TBD",
# get SRG-NMC interface
def test_10_srg_nmc_interface(self):
response = test_utils.check_netconf_node_request("ROADM-D1",
- "interface/SRG1-PP1-TXRX-nmc-2")
+ "interface/SRG1-PP1-TXRX-nmc-741:754")
res = response.json()
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(
- dict({"name": "SRG1-PP1-TXRX-nmc-2",
+ dict({"name": "SRG1-PP1-TXRX-nmc-741:754",
"supporting-circuit-pack-name": "3/0",
"circuit-id": "TBD",
"description": "TBD",
# Create ROADM-connection
def test_11_roadm_connection(self):
response = test_utils.check_netconf_node_request("ROADM-D1",
- "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-2")
+ "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-741:754")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertEqual("SRG1-PP1-TXRX-DEG1-TTP-TXRX-2",
+ self.assertEqual("SRG1-PP1-TXRX-DEG1-TTP-TXRX-741:754",
res['roadm-connections'][0]['connection-name'])
- self.assertEqual("SRG1-PP1-TXRX-nmc-2",
+ self.assertEqual("SRG1-PP1-TXRX-nmc-741:754",
res['roadm-connections'][0]['source']['src-if'])
- self.assertEqual("DEG1-TTP-TXRX-nmc-2",
+ self.assertEqual("DEG1-TTP-TXRX-nmc-741:754",
res['roadm-connections'][0]['destination']['dst-if'])
time.sleep(3)
response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
"node/ROADM-D1/yang-ext:mount/" +
"org-openroadm-device:org-openroadm-device/" +
- "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-2")
+ "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-741:754")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
"node/ROADM-D1/yang-ext:mount/" +
"org-openroadm-device:org-openroadm-device/" +
- "interface/SRG1-PP1-TXRX-nmc-2")
+ "interface/SRG1-PP1-TXRX-nmc-741:754")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
"node/ROADM-D1/yang-ext:mount/" +
"org-openroadm-device:org-openroadm-device/" +
- "interface/DEG1-TTP-TXRX-nmc-2")
+ "interface/DEG1-TTP-TXRX-nmc-741:754")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
response = test_utils.delete_request(test_utils.URL_CONFIG_NETCONF_TOPO +
"node/ROADM-D1/yang-ext:mount/" +
"org-openroadm-device:org-openroadm-device/" +
- "interface/DEG1-TTP-TXRX-mc-2")
+ "interface/DEG1-TTP-TXRX-mc-741:754")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
{"node-id": "ROADM-C1",
"dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG1-TTP-TXRX"},
{"node-id": "XPDR-C1",
- "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}])
+ "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
{"node-id": "ROADM-A1",
"src-tp": "DEG2-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
{"node-id": "XPDR-A1",
- "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}])
+ "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
"src-tp": "XPDR1-NETWORK1",
"node-id": "XPDR-C1"
}
- ]
+ ],
+ "lower-spectral-slot-number": 761,
+ "higher-spectral-slot-number": 768
}
}
response = test_utils.post_request(url, data)
def test_20_get_interface_XPDRA_XPDR1_NETWORK1(self):
response = test_utils.check_netconf_node_request(
"XPDR-A1",
- "interface/XPDR1-NETWORK1-1/org-openroadm-optical-channel-interfaces:och")
+ "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
self.assertEqual(196.1, res['org-openroadm-optical-channel-interfaces:och']['frequency'])
def test_21_get_roadmconnection_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(2.0, res['roadm-connections'][0]['target-output-power'])
def test_22_get_roadmconnection_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP1-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("power", res['roadm-connections'][0]['opticalControlMode'])
"dest-tp": "XPDR1-CLIENT1",
"node-id": "XPDR-A1"
}
- ]
+ ],
+ "lower-spectral-slot-number": 761,
+ "higher-spectral-slot-number": 768
}
}
response = test_utils.post_request(url, data)
def test_24_get_interface_XPDRC_XPDR1_NETWORK1(self):
response = test_utils.check_netconf_node_request(
"XPDR-C1",
- "interface/XPDR1-NETWORK1-1/org-openroadm-optical-channel-interfaces:och")
+ "interface/XPDR1-NETWORK1-761:768/org-openroadm-optical-channel-interfaces:och")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
self.assertEqual(196.1, res['org-openroadm-optical-channel-interfaces:och']['frequency'])
def test_25_get_roadmconnection_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("gainLoss", res['roadm-connections'][0]['opticalControlMode'])
"src-tp": "XPDR1-NETWORK1",
"node-id": "XPDR-C1"
}
- ]
+ ],
+ "lower-spectral-slot-number": 761,
+ "higher-spectral-slot-number": 768
}
}
response = test_utils.post_request(url, data)
self.assertIn('Success', res["output"]["result"])
def test_27_get_roadmconnection_ROADMA(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP1-TXRX-DEG2-TTP-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
self.assertEqual(-60, res['roadm-connections'][0]['target-output-power'])
def test_28_get_roadmconnection_ROADMC(self):
- response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP1-TXRX-1")
+ response = test_utils.check_netconf_node_request("ROADM-C1", "roadm-connections/DEG1-TTP-TXRX-SRG1-PP1-TXRX-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual("off", res['roadm-connections'][0]['opticalControlMode'])
{"node-id": "ROADM-C1",
"dest-tp": "SRG1-PP1-TXRX", "src-tp": "DEG1-TTP-TXRX"},
{"node-id": "XPDR-C1",
- "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}])
+ "dest-tp": "XPDR1-CLIENT1", "src-tp": "XPDR1-NETWORK1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
{"node-id": "ROADM-A1",
"src-tp": "DEG2-TTP-TXRX", "dest-tp": "SRG1-PP1-TXRX"},
{"node-id": "XPDR-A1",
- "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}])
+ "src-tp": "XPDR1-NETWORK1", "dest-tp": "XPDR1-CLIENT1"}],
+ 196.053125, 40, 196.025, 196.08125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
[{"node-id": "XPDR-A1",
"dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
{"node-id": "ROADM-A1",
- "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}])
+ "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
+ 196.1, 40, 196.075, 196.125, 753,
+ 760)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes', res["output"]["result"])
def test_34_get_interface_XPDRA_XPDR1_NETWORK2(self):
response = test_utils.check_netconf_node_request(
"XPDR-A1",
- "interface/XPDR1-NETWORK2-2/org-openroadm-optical-channel-interfaces:och")
+ "interface/XPDR1-NETWORK2-753:760/org-openroadm-optical-channel-interfaces:och")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertEqual(-5, res['org-openroadm-optical-channel-interfaces:och']['transmit-power'])
[{"node-id": "XPDR-A1",
"dest-tp": "XPDR1-NETWORK2", "src-tp": "XPDR1-CLIENT2"},
{"node-id": "ROADM-A1",
- "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}])
+ "dest-tp": "DEG2-TTP-TXRX", "src-tp": "SRG1-PP2-TXRX"}],
+ 196.053125, 40, 196.025, 196.08125, 761,
+ 768)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Request processed', res["output"]["result"])
# Check correct configuration of devices
def test_14_check_interface_och_spdra(self):
response = test_utils.check_netconf_node_request(
- "SPDR-SA1", "interface/XPDR1-NETWORK1-1")
+ "SPDR-SA1", "interface/XPDR1-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
+ self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
'administrative-state': 'inService',
'supporting-circuit-pack-name': 'CP1-CFP0',
'type': 'org-openroadm-interfaces:opticalChannel',
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
'administrative-state': 'inService',
'supporting-circuit-pack-name': 'CP1-CFP0',
- 'supporting-interface': 'XPDR1-NETWORK1-1',
+ 'supporting-interface': 'XPDR1-NETWORK1-761:768',
'type': 'org-openroadm-interfaces:otnOtu',
'supporting-port': 'CP1-CFP0-P1'
}
def test_16_check_interface_och_spdrc(self):
response = test_utils.check_netconf_node_request(
- "SPDR-SC1", "interface/XPDR1-NETWORK1-1")
+ "SPDR-SC1", "interface/XPDR1-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
+ self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
'administrative-state': 'inService',
'supporting-circuit-pack-name': 'CP1-CFP0',
'type': 'org-openroadm-interfaces:opticalChannel',
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
'administrative-state': 'inService',
'supporting-circuit-pack-name': 'CP1-CFP0',
- 'supporting-interface': 'XPDR1-NETWORK1-1',
+ 'supporting-interface': 'XPDR1-NETWORK1-761:768',
'type': 'org-openroadm-interfaces:otnOtu',
'supporting-port': 'CP1-CFP0-P1'
}
def test_04_service_path_create_OCH_OTU4(self):
response = test_utils.service_path_request("create", "service_OCH_OTU4", "1",
- [{"node-id": "SPDR-SA1", "dest-tp": "XPDR1-NETWORK1"}])
+ [{"node-id": "SPDR-SA1", "dest-tp": "XPDR1-NETWORK1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn(
{'node-id': 'SPDR-SA1',
'otu-interface-id': ['XPDR1-NETWORK1-OTU'],
- 'och-interface-id': ['XPDR1-NETWORK1-1']}, res["output"]['node-interface'])
+ 'och-interface-id': ['XPDR1-NETWORK1-761:768']}, res["output"]['node-interface'])
def test_05_get_portmapping_NETWORK1(self):
response = test_utils.portmapping_request("SPDR-SA1/mapping/XPDR1-NETWORK1")
res['mapping'])
def test_06_check_interface_och(self):
- response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
+ response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertDictEqual(dict(res['interface'][0], **{'name': 'XPDR1-NETWORK1-1',
+ self.assertDictEqual(dict(res['interface'][0], **{'name': 'XPDR1-NETWORK1-761:768',
'administrative-state': 'inService',
'supporting-circuit-pack-name': 'CP1-CFP0',
'type': 'org-openroadm-interfaces:opticalChannel',
input_dict_1 = {'name': 'XPDR1-NETWORK1-OTU',
'administrative-state': 'inService',
'supporting-circuit-pack-name': 'CP1-CFP0',
- 'supporting-interface': 'XPDR1-NETWORK1-1',
+ 'supporting-interface': 'XPDR1-NETWORK1-761:768',
'type': 'org-openroadm-interfaces:otnOtu',
'supporting-port': 'CP1-CFP0-P1'
}
def test_23_service_path_delete_OCH_OTU4(self):
response = test_utils.service_path_request("delete", "service_OCH_OTU4", "1",
- [{"node-id": "SPDR-SA1", "dest-tp": "XPDR1-NETWORK1"}])
+ [{"node-id": "SPDR-SA1", "dest-tp": "XPDR1-NETWORK1"}],
+ 196.1, 40, 196.075, 196.125, 761,
+ 768)
time.sleep(3)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
"tp-id": ""
}
}
- ]
+ ],
+ "transportpce-renderer:aToZ-min-frequency": 196.075,
+ "transportpce-renderer:aToZ-max-frequency": 196.125
},
"transportpce-renderer:zToA-direction": {
"transportpce-renderer:zToA-wavelength-number": "1",
"tp-id": ""
}
}
- ]
+ ],
+ "transportpce-renderer:zToA-min-frequency": 196.075,
+ "transportpce-renderer:zToA-max-frequency": 196.125
}
}
}
}
response = test_utils.post_request(url, data)
time.sleep(3)
+ print(response.json())
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Operation Successful',
# Test OCH-OTU interfaces on SPDR-A1
def test_04_check_interface_och(self):
- response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-1")
+ response = test_utils.check_netconf_node_request("SPDR-SA1", "interface/XPDR1-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
+ self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-761:768',
'administrative-state': 'inService',
'supporting-circuit-pack-name': 'CP1-CFP0',
'type': 'org-openroadm-interfaces:opticalChannel',
# Test OCH-OTU interfaces on SPDR-C1
def test_06_check_interface_och(self):
- response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-1")
+ response = test_utils.check_netconf_node_request("SPDR-SC1", "interface/XPDR1-NETWORK1-761:768")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictEqual(dict({'name': 'XPDR1-NETWORK1-1',
"renderer:dest-tp": "DEG1-TTP-TXRX"},
{"renderer:node-id": "XPDR-A1",
"renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}])
+ "renderer:dest-tp": "XPDR1-NETWORK1"}],
+ 195.8, 40, 195.775, 195.825, 713,
+ 720)
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertIn('Roadm-connection successfully created for nodes: ROADM-A1', res["output"]["result"])
def test_06_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-nmc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-nmc-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'name': 'DEG1-TTP-TXRX-nmc-7',
+ 'name': 'DEG1-TTP-TXRX-nmc-713:720',
'administrative-state': 'inService',
'supporting-circuit-pack-name': '1/0',
'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
res['interface'][0]['org-openroadm-network-media-channel-interfaces:nmc-ctp'])
def test_07_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-mc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-mc-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
res['interface'][0]['org-openroadm-media-channel-interfaces:mc-ttp'])
def test_08_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-nmc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-nmc-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'name': 'SRG1-PP3-TXRX-nmc-7',
+ 'name': 'SRG1-PP3-TXRX-nmc-713:720',
'administrative-state': 'inService',
'supporting-circuit-pack-name': '3/0',
'type': 'org-openroadm-interfaces:networkMediaChannelConnectionTerminationPoint',
# -mc supporting interfaces must not be created for SRG, only degrees
def test_09_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-mc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-mc-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn(
res['errors']['error'])
def test_10_service_path_create_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP3-TXRX-DEG1-TTP-TXRX-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "roadm-connections/SRG1-PP3-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'connection-name': 'SRG1-PP3-TXRX-DEG1-TTP-TXRX-7',
+ 'connection-name': 'SRG1-PP3-TXRX-DEG1-TTP-TXRX-713:720',
'opticalControlMode': 'off'
}, **res['roadm-connections'][0]),
res['roadm-connections'][0]
)
self.assertDictEqual(
- {'src-if': 'SRG1-PP3-TXRX-nmc-7'},
+ {'src-if': 'SRG1-PP3-TXRX-nmc-713:720'},
res['roadm-connections'][0]['source'])
self.assertDictEqual(
- {'dst-if': 'DEG1-TTP-TXRX-nmc-7'},
+ {'dst-if': 'DEG1-TTP-TXRX-nmc-713:720'},
res['roadm-connections'][0]['destination'])
def test_11_service_path_create_xpdr_check(self):
- response = test_utils.check_netconf_node_request("XPDR-A1", "interface/XPDR1-NETWORK1-7")
+ response = test_utils.check_netconf_node_request("XPDR-A1", "interface/XPDR1-NETWORK1-713:720")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
# the following statement replaces self.assertDictContainsSubset deprecated in python 3.2
self.assertDictEqual(
dict({
- 'name': 'XPDR1-NETWORK1-7',
+ 'name': 'XPDR1-NETWORK1-713:720',
'administrative-state': 'inService',
'supporting-circuit-pack-name': '1/0/1-PLUG-NET',
'type': 'org-openroadm-interfaces:opticalChannel',
"renderer:dest-tp": "DEG1-TTP-TXRX"},
{"renderer:node-id": "XPDR-A1",
"renderer:src-tp": "XPDR1-CLIENT1",
- "renderer:dest-tp": "XPDR1-NETWORK1"}])
+ "renderer:dest-tp": "XPDR1-NETWORK1"}],
+ 195.8, 40, 195.775, 195.825, 713,
+ 720)
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(response.json(), {
'output': {'result': 'Request processed', 'success': True}})
def test_18_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-mc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-mc-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn(
res['errors']['error'])
def test_19_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-nmc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/DEG1-TTP-TXRX-nmc-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn(
res['errors']['error'])
def test_20_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-mc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-mc-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn({
res['errors']['error'])
def test_21_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-nmc-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-nmc-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn({
res['errors']['error'])
def test_22_service_path_delete_rdm_check(self):
- response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-DEG1-TTP-TXRX-7")
+ response = test_utils.check_netconf_node_request("ROADM-A1", "interface/SRG1-PP3-TXRX-DEG1-TTP-TXRX-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn({
res['errors']['error'])
def test_23_service_path_delete_xpdr_check(self):
- response = test_utils.check_netconf_node_request("XPDR-A1", "interface/XPDR1-NETWORK1-7")
+ response = test_utils.check_netconf_node_request("XPDR-A1", "interface/XPDR1-NETWORK1-713:720")
self.assertEqual(response.status_code, requests.codes.conflict)
res = response.json()
self.assertIn({
def post_request(url, data):
if data:
+ print(json.dumps(data))
return requests.request(
"POST", url.format(RESTCONF_BASE_URL),
data=json.dumps(data),
return post_request(URL_SERV_DELETE, attr)
-def service_path_request(operation: str, servicename: str, wavenumber: str, nodes):
+def service_path_request(operation: str, servicename: str, wavenumber: str, nodes, centerfreq: str,
+ slotwidth: int, minfreq: float, maxfreq: float, lowerslotnumber: int,
+ higherslotnumber: int):
attr = {"renderer:input": {
"renderer:service-name": servicename,
"renderer:wave-number": wavenumber,
- "renderer:modulation-format": "qpsk",
+ "renderer:modulation-format": "dp-qpsk",
"renderer:operation": operation,
- "renderer:nodes": nodes}}
+ "renderer:nodes": nodes,
+ "renderer:center-freq": centerfreq,
+ "renderer:width": slotwidth,
+ "renderer:min-freq": minfreq,
+ "renderer:max-freq": maxfreq,
+ "renderer:lower-spectral-slot-number": lowerslotnumber,
+ "renderer:higher-spectral-slot-number": higherslotnumber}}
return post_request(URL_SERVICE_PATH, attr)
Code Review / transportpce.git / commitdiff