import java.math.BigDecimal;
import java.util.List;
import java.util.Optional;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.otn.renderer.input.Nodes;
*
* @param deviceId
* Device id.
- * @param waveNumber
- * Wavelength number.
* @param srcTp
* 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.
+ * @param spectrumInformation SpectrumInformation
* @return optional of connection number
*/
- Optional<String> postCrossConnect(String deviceId, Long waveNumber, String srcTp, String destTp,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber);
+ Optional<String> postCrossConnect(String deviceId, String srcTp, String destTp,
+ SpectrumInformation spectrumInformation);
/**
* This method does a delete(edit-config) on roadm connection subtree for a
*
* @param nodeId
* node-id of NE.
- * @param waveNumber
- * Wavelength number.
* @param srcTp
* Source logical connection point.
* @param destTp
* @throws OpenRoadmInterfaceException
* an exception at OpenRoadm interface.
*/
- List<?> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ List<?> getConnectionPortTrail(String nodeId, String srcTp, String destTp, int lowerSpectralSlotNumber,
+ int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException;
/**
import java.util.List;
import java.util.Optional;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.OpticalControlMode;
}
- public Optional<String> postCrossConnect(String nodeId, Long waveNumber, String srcTp, String destTp,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber) {
+ public Optional<String> postCrossConnect(String nodeId, String srcTp, String destTp,
+ SpectrumInformation spectrumInformation) {
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,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ return crossConnectImpl121.postCrossConnect(nodeId, srcTp, destTp, spectrumInformation);
}
else if (OPENROADM_DEVICE_VERSION_2_2_1.equals(openRoadmVersion)) {
LOG.info("Device Version is 2.2");
return crossConnectImpl221.postCrossConnect(nodeId, srcTp, destTp,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ spectrumInformation);
}
LOG.info("Device Version not found");
return Optional.empty();
return null;
}
- public List<?> getConnectionPortTrail(String nodeId, Long waveNumber, String srcTp, String destTp,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ public List<?> getConnectionPortTrail(String nodeId, String srcTp, String destTp, int lowerSpectralSlotNumber,
+ int higherSpectralSlotNumber)
throws OpenRoadmInterfaceException {
String openRoadmVersion = mappingUtils.getOpenRoadmVersion(nodeId);
if (OPENROADM_DEVICE_VERSION_1_2_1.equals(openRoadmVersion)) {
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.OpticalControlMode;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.PowerDBm;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.opendaylight.yangtools.yang.common.RpcResult;
-import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
Timeouts.DEVICE_READ_TIMEOUT_UNIT);
}
- 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));
+ public Optional<String> postCrossConnect(String deviceId, String srcTp, String destTp,
+ SpectrumInformation spectrumInformation) {
RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder();
- String connectionNumber = generateConnectionNumber(srcTp, destTp, spectralSlotName);
+ String connectionNumber = spectrumInformation.getIdentifierFromParams(srcTp, destTp);
rdmConnBldr.setConnectionNumber(connectionNumber);
- rdmConnBldr.setWavelengthNumber(Uint32.valueOf(waveNumber));
+ rdmConnBldr.setWavelengthNumber(spectrumInformation.getWaveLength());
rdmConnBldr.setOpticalControlMode(OpticalControlMode.Off);
- rdmConnBldr.setSource(new SourceBuilder().setSrcIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
- srcTp, spectralSlotName)).build());
+ rdmConnBldr.setSource(new SourceBuilder().setSrcIf(spectrumInformation.getIdentifierFromParams(srcTp))
+ .build());
rdmConnBldr.setDestination(new DestinationBuilder()
- .setDstIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, destTp, spectralSlotName))
+ .setDstIf(spectrumInformation.getIdentifierFromParams(destTp))
.build());
InstanceIdentifier<RoadmConnections> rdmConnectionIID = InstanceIdentifier.create(OrgOpenroadmDevice.class)
.child(RoadmConnections.class, new RoadmConnectionsKey(rdmConnBldr.getConnectionNumber()));
try {
commit.get();
LOG.info("Roadm-connection successfully created: {}-{}-{}-{}", srcTp, destTp,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ spectrumInformation.getLowerSpectralSlotNumber(),
+ spectrumInformation.getHigherSpectralSlotNumber());
return Optional.of(connectionNumber);
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to post {}. Exception: ", rdmConnBldr.build(), e);
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.OpticalControlMode;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.PowerDBm;
}
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);
+ SpectrumInformation spectrumInformation) {
+ String connectionNumber = spectrumInformation.getIdentifierFromParams(srcTp, destTp);
RoadmConnectionsBuilder rdmConnBldr = new RoadmConnectionsBuilder()
.setConnectionName(connectionNumber)
.setOpticalControlMode(OpticalControlMode.Off)
.setSource(new SourceBuilder()
- .setSrcIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
- srcTp,
- "nmc",
- spectralSlotName))
+ .setSrcIf(spectrumInformation.getIdentifierFromParams(srcTp,"nmc"))
.build())
.setDestination(new DestinationBuilder()
- .setDstIf(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
- destTp,
- "nmc",
- spectralSlotName))
+ .setDstIf(spectrumInformation.getIdentifierFromParams(destTp,"nmc"))
.build());
InstanceIdentifier<RoadmConnections> rdmConnectionIID =
deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT);
try {
commit.get();
- LOG.info("Roadm-connection successfully created: {}-{}-{}-{}", srcTp, destTp, lowerSpectralSlotNumber,
- higherSpectralSlotNumber);
+ LOG.info("Roadm-connection successfully created: {}-{}-{}-{}", srcTp, destTp,
+ spectrumInformation.getLowerSpectralSlotNumber(),
+ spectrumInformation.getHigherSpectralSlotNumber());
return Optional.of(connectionNumber);
} catch (InterruptedException | ExecutionException e) {
LOG.warn("Failed to post {}. Exception: ", rdmConnBldr.build(), e);
+++ /dev/null
-/*
- * Copyright © 2017 Orange, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.transportpce.common.fixedflex;
-
-public final class FixedFlexImpl implements FixedFlexInterface {
- private long index;
- private double centerFrequency;
- private double start;
- private double stop;
- private double wavelength;
- // wavelengthSpacing is in GHz
- float wavelengthSpacing = 50;
- // BEGIN_WAVELENGTH is in nm: f or F is appended to treat it explicitly as simple float (and not double float)
- static final float BEGIN_WAVELENGTH = 1528.77f;
- // java double is double float - d or D is appended to treat it explicitly as double float
- static final double PRECISION = 10000d;
-
- public FixedFlexImpl(Long index, double centreFrequency, double start, double stop, double wavelength) {
- this.index = index;
- this.centerFrequency = centreFrequency;
- this.start = start;
- this.stop = stop;
- this.wavelength = wavelength;
- }
-
- public FixedFlexImpl() {
- this.index = 0L;
- this.centerFrequency = 0;
- this.start = 0;
- this.stop = 0;
- this.wavelength = 0;
- }
-
- public FixedFlexImpl(long wlIndex) {
- this.centerFrequency = 196.1 - (wlIndex - 1) * wavelengthSpacing / 1000;
- // Truncate the value to the two decimal places
- this.centerFrequency = Math.round(this.centerFrequency * PRECISION) / PRECISION;
- this.start = this.centerFrequency - (wavelengthSpacing / 2) / 1000;
- this.start = Math.round(this.start * PRECISION) / PRECISION;
- this.stop = this.centerFrequency + (wavelengthSpacing / 2) / 1000;
- this.stop = Math.round(this.stop * PRECISION) / PRECISION;
- this.wavelength = BEGIN_WAVELENGTH + ((wlIndex - 1) * 0.40);
- this.wavelength = Math.round(this.wavelength * PRECISION) / PRECISION;
- }
-
- @Override
- /**
- * @param index Wavelength number
- * @return Returns FixedFlexImp object with the calculated result.
- **/
- public FixedFlexImpl getFixedFlexWaveMapping(long wlIndex) {
- // In Flex grid -35 <= n <= 60
- long mappedWL = 61 - wlIndex;
- FixedFlexImpl fixedFlex = new FixedFlexImpl();
- fixedFlex.centerFrequency = 193.1 + (50.0 / 1000.0) * mappedWL;
- fixedFlex.centerFrequency = Math.round(fixedFlex.centerFrequency * PRECISION) / PRECISION;
- fixedFlex.wavelength = BEGIN_WAVELENGTH + ((wlIndex - 1) * 0.40);
- fixedFlex.wavelength = Math.round(fixedFlex.wavelength * PRECISION) / PRECISION;
- fixedFlex.start = 193.1 + (50.0 * mappedWL - 25) / 1000.0;
- fixedFlex.start = Math.round(fixedFlex.start * PRECISION) / PRECISION;
- fixedFlex.stop = 193.1 + (50.0 * mappedWL + 25) / 1000.0;
- fixedFlex.stop = Math.round(fixedFlex.stop * PRECISION) / PRECISION;
- fixedFlex.index = wlIndex;
- return fixedFlex;
- }
-
- public double getCenterFrequency() {
- return centerFrequency;
- }
-
- public double getStart() {
- return start;
- }
-
- public long getIndex() {
- return index;
- }
-
- public double getStop() {
- return stop;
- }
-
- public double getWavelength() {
- return wavelength;
- }
-}
+++ /dev/null
-/*
- * Copyright © 2017 Orange, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.transportpce.common.fixedflex;
-/**
- * <p>
- * Mapping 2.2 devices to Fixed flex.
- * </p>
- **/
-
-public interface FixedFlexInterface {
- /**
- * Calculates the center frequency, wavelength, start and stop for a wavelength number.
- *
- * @param index Wavelength number
- * @return Returns FixedFlexImp object with the calculated result.
- */
- FixedFlexImpl getFixedFlexWaveMapping(long index);
-
- double getCenterFrequency();
-
- double getStart();
-
- double getStop();
-
- double getWavelength();
-
- long getIndex();
-}
-
+++ /dev/null
-/*
- * Copyright © 2020 AT&T, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.transportpce.common.fixedflex;
-
-public class FlexGridImpl implements FlexGridInterface {
- private double start;
- private double stop;
- static final double PRECISION = 100000d;
-
- public FlexGridImpl(double start, double stop) {
- this.start = start;
- this.stop = stop;
- }
-
- public FlexGridImpl() {
- this.start = 0;
- this.stop = 0;
- }
-
- @Override
- public FlexGridImpl getFlexWaveMapping(float centerFrequency, float slotwidth) {
- FlexGridImpl flexGridImpl = new FlexGridImpl();
- flexGridImpl.start = centerFrequency - (slotwidth / 2) / 1000.0;
- flexGridImpl.start = Math.round(flexGridImpl.start * PRECISION) / PRECISION;
- flexGridImpl.stop = centerFrequency + (slotwidth / 2) / 1000.0;
- flexGridImpl.stop = Math.round(flexGridImpl.stop * PRECISION) / PRECISION;
- return flexGridImpl;
- }
-
- public double getStart() {
- return start;
- }
-
- public double getStop() {
- return stop;
- }
-}
-
+++ /dev/null
-/*
- * Copyright © 2020 AT&T, Inc. and others. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-package org.opendaylight.transportpce.common.fixedflex;
-
-public interface FlexGridInterface {
-
- FlexGridImpl getFlexWaveMapping(float centerFrequency, float slotwidth);
-
- double getStart();
-
- double getStop();
-}
WIDTH_40, SLOT_WIDTH_50,
WIDTH_80, SLOT_WIDTH_87_5);
- public static final int FREQUENCY_PRECISION = 4;
+ public static final int FIXED_GRID_FREQUENCY_PRECISION = 4;
+
+ public static final int FLEX_GRID_FREQUENCY_PRECISION = 5;
/**
* Map to associate service rate and modulation format to frequency slot width.
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.ServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyTHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
return getIndexFromFrequency(frequency);
}
+ /**
+ * Create spectrum information from service path input.
+ * @param input ServicePathInput
+ * @return SpectrumInformation
+ */
+ public static SpectrumInformation initSpectrumInformationFromServicePathInput(ServicePathInput input) {
+ if (input.getLowerSpectralSlotNumber() == null || input.getHigherSpectralSlotNumber() == null) {
+ LOG.error("low and higher spectral slot numbers cannot be null");
+ throw new IllegalArgumentException("low and higher spectral slot numbers cannot be null");
+ }
+ SpectrumInformation spectrumInformation = new SpectrumInformation();
+ spectrumInformation.setLowerSpectralSlotNumber(input.getLowerSpectralSlotNumber().intValue());
+ spectrumInformation.setHigherSpectralSlotNumber(input.getHigherSpectralSlotNumber().intValue());
+ if (input.getWaveNumber() != null) {
+ spectrumInformation.setWaveLength(input.getWaveNumber());
+ }
+ if (input.getMinFreq() != null) {
+ spectrumInformation.setMinFrequency(input.getMinFreq().getValue());
+ } else {
+ spectrumInformation.setMinFrequency(
+ GridUtils.getStartFrequencyFromIndex(input.getLowerSpectralSlotNumber().intValue() - 1));
+ }
+ if (input.getMaxFreq() != null) {
+ spectrumInformation.setMaxFrequency(input.getMaxFreq().getValue());
+ } else {
+ spectrumInformation.setMaxFrequency(
+ GridUtils.getStopFrequencyFromIndex(input.getHigherSpectralSlotNumber().intValue() - 1));
+ }
+ if (input.getCenterFreq() != null) {
+ spectrumInformation.setCenterFrequency(input.getCenterFreq().getValue());
+ } else {
+ spectrumInformation.setCenterFrequency(GridUtils
+ .getCentralFrequency(spectrumInformation.getMinFrequency(),
+ spectrumInformation.getMaxFrequency()).getValue());
+ }
+ if (input.getWidth() != null) {
+ spectrumInformation.setWidth(input.getWidth().getValue());
+ }
+ if (input.getModulationFormat() != null) {
+ spectrumInformation.setModulationFormat(input.getModulationFormat());
+ }
+ return spectrumInformation;
+ }
+
}
--- /dev/null
+/*
+ * Copyright © 2020 Orange, Inc. and others. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0 which accompanies this distribution,
+ * and is available at http://www.eclipse.org/legal/epl-v10.html
+ */
+
+package org.opendaylight.transportpce.common.fixedflex;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes.ModulationFormat;
+import org.opendaylight.yangtools.yang.common.Uint32;
+
+/**
+ * Spectrum information for cross connect and openroadm interfaces management.
+ */
+public class SpectrumInformation {
+ private Uint32 waveLength;
+ private int lowerSpectralSlotNumber;
+ private int higherSpectralSlotNumber;
+ private BigDecimal width = GridConstant.WIDTH_40;
+ private BigDecimal centerFrequency;
+ private BigDecimal minFrequency;
+ private BigDecimal maxFrequency;
+ private String modulationFormat = ModulationFormat.DpQpsk.name();
+ private int scale = GridConstant.FIXED_GRID_FREQUENCY_PRECISION;
+
+ public String getSpectralSlotFormat() {
+ return String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
+ String.valueOf(lowerSpectralSlotNumber),
+ String.valueOf(higherSpectralSlotNumber));
+ }
+
+ public String getIdentifierFromParams(String...params) {
+ String joinedParams = String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, params);
+ return String.join(GridConstant.NAME_PARAMETERS_SEPARATOR, joinedParams, getSpectralSlotFormat());
+ }
+
+ /**
+ * Get the wavelength.
+ * @return the waveLength
+ */
+ public Uint32 getWaveLength() {
+ return waveLength;
+ }
+
+ /**
+ * Set the wavelength.
+ * @param waveLength the waveLength to set
+ */
+ public void setWaveLength(Uint32 waveLength) {
+ this.waveLength = waveLength;
+ if (waveLength == null || waveLength.longValue() == GridConstant.IRRELEVANT_WAVELENGTH_NUMBER) {
+ scale = GridConstant.FLEX_GRID_FREQUENCY_PRECISION;
+ }
+ }
+
+ /**
+ * Get the lower spectral slot number.
+ * @return the lowerSpectralSlotNumber
+ */
+ public int getLowerSpectralSlotNumber() {
+ return lowerSpectralSlotNumber;
+ }
+
+ /**
+ * Set the lower spectral slot number.
+ * @param lowerSpectralSlotNumber the lowerSpectralSlotNumber to set
+ */
+ public void setLowerSpectralSlotNumber(int lowerSpectralSlotNumber) {
+ this.lowerSpectralSlotNumber = lowerSpectralSlotNumber;
+ }
+
+ /**
+ * Get the higher spectral slot number.
+ * @return the higherSpectralSlotNumber
+ */
+ public int getHigherSpectralSlotNumber() {
+ return higherSpectralSlotNumber;
+ }
+
+ /**
+ * Set the higher spectral slot number.
+ * @param higherSpectralSlotNumber the higherSpectralSlotNumber to set
+ */
+ public void setHigherSpectralSlotNumber(int higherSpectralSlotNumber) {
+ this.higherSpectralSlotNumber = higherSpectralSlotNumber;
+ }
+
+ /**
+ * Get the frequency width.
+ * @return the width
+ */
+ public BigDecimal getWidth() {
+ return width;
+ }
+
+ /**
+ * Set the frequency width.
+ * @param width the width to set
+ */
+ public void setWidth(BigDecimal width) {
+ this.width = width;
+ }
+
+ /**
+ * Get center frequency.
+ * @return the centerFrequency
+ */
+ public BigDecimal getCenterFrequency() {
+ return centerFrequency;
+ }
+
+ /**
+ * Set center frequency.
+ * @param centerFrequency the centerFrequency to set
+ */
+ public void setCenterFrequency(BigDecimal centerFrequency) {
+ this.centerFrequency = centerFrequency.setScale(scale, RoundingMode.HALF_EVEN);
+ }
+
+ /**
+ * Get min frequency.
+ * @return the minFrequency
+ */
+ public BigDecimal getMinFrequency() {
+ return minFrequency;
+ }
+
+ /**
+ * Set min frequency.
+ * @param minFrequency the minFrequency to set
+ */
+ public void setMinFrequency(BigDecimal minFrequency) {
+ this.minFrequency = minFrequency.setScale(scale, RoundingMode.HALF_EVEN);
+ }
+
+ /**
+ * Get max frequency.
+ * @return the maxFrequency
+ */
+ public BigDecimal getMaxFrequency() {
+ return maxFrequency;
+ }
+
+ /**
+ * Set max frequency.
+ * @param maxFrequency the maxFrequency to set
+ */
+ public void setMaxFrequency(BigDecimal maxFrequency) {
+ this.maxFrequency = maxFrequency.setScale(scale, RoundingMode.HALF_EVEN);
+ }
+
+ /**
+ * Get the modulation format.
+ * @return the modulationFormat
+ */
+ public String getModulationFormat() {
+ return modulationFormat;
+ }
+
+ /**
+ * Set the modulation format.
+ * @param modulationFormat the modulationFormat to set
+ */
+ public void setModulationFormat(String modulationFormat) {
+ this.modulationFormat = modulationFormat;
+ }
+
+ /*
+ * (non-Javadoc)
+ *
+ * @see java.lang.Object#toString()
+ */
+ @Override
+ public String toString() {
+ StringBuilder builder = new StringBuilder();
+ builder.append("SpectrumInformation [waveLength=").append(waveLength).append(", lowerSpectralSlotNumber=")
+ .append(lowerSpectralSlotNumber).append(", higherSpectralSlotNumber=").append(higherSpectralSlotNumber)
+ .append(", width=").append(width).append(", centerFrequency=").append(centerFrequency)
+ .append(", minFrequency=").append(minFrequency).append(", maxFrequency=").append(maxFrequency)
+ .append(", modulationFormat=").append(modulationFormat).append(", scale=").append(scale).append("]");
+ return builder.toString();
+ }
+}
<argument ref="crossConnect221" />
</bean>
- <bean id="FixedFlexImpl" class="org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl" >
- </bean>
-
- <bean id="FlexGridImpl" class="org.opendaylight.transportpce.common.fixedflex.FlexGridImpl" >
- </bean>
-
<service ref="deviceTransactionManager" interface="org.opendaylight.transportpce.common.device.DeviceTransactionManager" />
<service ref="networkTransactionImpl" interface="org.opendaylight.transportpce.common.network.NetworkTransactionService" />
<service ref="mappingUtils" interface="org.opendaylight.transportpce.common.mapping.MappingUtils" />
- <service ref="FixedFlexImpl" interface="org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface"/>
-
- <service ref="FlexGridImpl" interface="org.opendaylight.transportpce.common.fixedflex.FlexGridInterface"/>
-
</blueprint>
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev161014.OpticalControlMode;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPorts;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.degree.ConnectionPortsBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class CrossConnectImpl121Test {
private CrossConnectImpl121 crossConnectImpl121 = null;
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", 1, 8);
- Assert.assertEquals(res.get(), "srcTp-destTp-1:8");
+ SpectrumInformation spectrumInformation = new SpectrumInformation();
+ spectrumInformation.setWaveLength(Uint32.valueOf(1));
+ spectrumInformation.setLowerSpectralSlotNumber(761);
+ spectrumInformation.setHigherSpectralSlotNumber(768);
+ Optional<String> res = crossConnectImpl121.postCrossConnect("deviceId", "srcTp", "destTp", spectrumInformation);
+ Assert.assertEquals(res.get(), "srcTp-destTp-761:768");
}
// TODO : fix commit
import org.opendaylight.transportpce.common.device.DeviceTransaction;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.NodesKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.OpticalControlMode;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev201211.otn.renderer.input.Nodes;
import org.opendaylight.yangtools.util.concurrent.FluentFutures;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class CrossConnectImpl221Test {
private CrossConnectImpl221 crossConnectImpl221 = null;
Mockito.when(rwTransactionMock.commit()).thenReturn(FluentFutures.immediateNullFluentFuture());
deviceTransactionManager = new DeviceTransactionManagerImpl(mountPointServiceMock, 3000);
crossConnectImpl221 = new CrossConnectImpl221(deviceTransactionManager);
- Optional res = crossConnectImpl221.postCrossConnect("deviceId", "srcTp", "destTp", 1, 8);
- Assert.assertEquals(res.get(), "srcTp-destTp-1:8");
+ SpectrumInformation spectrumInformation = new SpectrumInformation();
+ spectrumInformation.setWaveLength(Uint32.valueOf(1));
+ spectrumInformation.setLowerSpectralSlotNumber(761);
+ spectrumInformation.setHigherSpectralSlotNumber(768);
+ Optional res = crossConnectImpl221.postCrossConnect("deviceId", "srcTp", "destTp", spectrumInformation);
+ Assert.assertEquals(res.get(), "srcTp-destTp-761:768");
}
@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;
import org.junit.Before;
import org.junit.Test;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnections;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class CrossConnectImplTest {
@Test
public void postCrossConnect() {
- Optional<?> res = crossConnectImpl.postCrossConnect("100", 100L, "srcTp", "destTp", 1, 8);
+ SpectrumInformation spectrumInformation = new SpectrumInformation();
+ spectrumInformation.setWaveLength(Uint32.valueOf(1));
+ spectrumInformation.setLowerSpectralSlotNumber(761);
+ spectrumInformation.setHigherSpectralSlotNumber(768);
+ Optional<?> res = crossConnectImpl.postCrossConnect("100", "srcTp", "destTp", spectrumInformation);
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(), eq(1), eq(8)))
+ when(crossConnectImpl121.postCrossConnect(any(), any(), any(), any()))
.thenReturn(Optional.of("Value"));
- res = crossConnectImpl.postCrossConnect("100", 100L, "srcTp", "destTp", 1, 8);
+ res = crossConnectImpl.postCrossConnect("100", "srcTp", "destTp", spectrumInformation);
Assert.assertTrue("Optional object should have a value",res.isPresent());
}
+++ /dev/null
-/*
- * Copyright © 2020 Orange. All rights reserved.
- *
- * This program and the accompanying materials are made available under the
- * terms of the Eclipse Public License v1.0 which accompanies this distribution,
- * and is available at http://www.eclipse.org/legal/epl-v10.html
- */
-
-package org.opendaylight.transportpce.common.fixedflex;
-
-import org.junit.Assert;
-import org.junit.Before;
-import org.junit.Test;
-
-public class FixedFlexImplTest {
-
- FixedFlexImpl fixedFlex = null;
-
- @Before
- public void setUp() {
- fixedFlex = new FixedFlexImpl();
- }
-
- @Test
- public void getFixedFlexWaveMappingTest() {
- FixedFlexImpl res = fixedFlex.getFixedFlexWaveMapping(10L);
-
- Assert.assertEquals(res.getIndex(),10);
- Assert.assertEquals(res.getCenterFrequency(),195.65,.5);
- Assert.assertEquals(res.getStart(),195.625,.5);
- Assert.assertEquals(res.getStop(),195.675,.5);
- Assert.assertEquals(res.getWavelength(),1532.37,.5);
- }
-
- @Test
- public void fixedFlexImpl1() {
- FixedFlexImpl res = new FixedFlexImpl(10L);
-
- Assert.assertEquals(res.getIndex(),0);
- Assert.assertEquals(res.getCenterFrequency(),195.65,.5);
- Assert.assertEquals(res.getStart(),195.625,.5);
- Assert.assertEquals(res.getStop(),195.675,.5);
- Assert.assertEquals(res.getWavelength(),1532.37,.5);
- }
-
- @Test
- public void fixedFlexImpl2() {
- FixedFlexImpl res = new FixedFlexImpl(1L, 19, 19, 19, 12);
-
- Assert.assertEquals(res.getIndex(),1L);
- Assert.assertEquals(res.getCenterFrequency(),19,.5);
- Assert.assertEquals(res.getStart(),19,.5);
- Assert.assertEquals(res.getStop(),19,.5);
- Assert.assertEquals(res.getWavelength(),12,.5);
- }
-}
import java.util.Map;
import org.junit.Test;
import org.opendaylight.transportpce.common.ServiceRateConstant;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.ServicePathInput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.ServicePathInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyGHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev200529.FrequencyTHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019.ModulationFormat;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.available.freq.map.AvailFreqMaps;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev200529.available.freq.map.AvailFreqMapsKey;
+import org.opendaylight.yangtools.yang.common.Uint32;
public class GridUtilsTest {
GridUtils.getCentralFrequencyWithPrecision(BigDecimal.valueOf(191.3244445),
BigDecimal.valueOf(191.3754457788), 4));
}
+
+ @Test
+ public void initSpectrumInformationFromServicePathInputTest() {
+ ServicePathInput input = new ServicePathInputBuilder()
+ .setWaveNumber(Uint32.valueOf(1))
+ .setCenterFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyTHz(BigDecimal.valueOf(196.1)))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setMaxFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyTHz(BigDecimal.valueOf(196.125)))
+ .setMinFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyTHz(BigDecimal.valueOf(196.075)))
+ .setWidth(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyGHz(GridConstant.WIDTH_40))
+ .build();
+ SpectrumInformation spectrumInformation = GridUtils.initSpectrumInformationFromServicePathInput(input);
+ assertEquals("Width should be 40", BigDecimal.valueOf(40), spectrumInformation.getWidth());
+ assertEquals("Wavelength should be 1", Uint32.valueOf(1), spectrumInformation.getWaveLength());
+ assertEquals("Center freq should be 196.1", BigDecimal.valueOf(196.1).setScale(4),
+ spectrumInformation.getCenterFrequency());
+ assertEquals("Lower slot number should be 761", 761, spectrumInformation.getLowerSpectralSlotNumber());
+ assertEquals("Higher slot number should be 768", 768, spectrumInformation.getHigherSpectralSlotNumber());
+ assertEquals("Min freq should be 196.075", BigDecimal.valueOf(196.075).setScale(4),
+ spectrumInformation.getMinFrequency());
+ assertEquals("Max freq should be 196.125", BigDecimal.valueOf(196.125).setScale(4),
+ spectrumInformation.getMaxFrequency());
+ }
+
+ @Test
+ public void initSpectrumInformationFromServicePathInputNoCenterFreqTest() {
+ ServicePathInput input = new ServicePathInputBuilder()
+ .setWaveNumber(Uint32.valueOf(1))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setMaxFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyTHz(BigDecimal.valueOf(196.125)))
+ .setMinFreq(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyTHz(BigDecimal.valueOf(196.075)))
+ .setWidth(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyGHz(GridConstant.WIDTH_40))
+ .build();
+ SpectrumInformation spectrumInformation = GridUtils.initSpectrumInformationFromServicePathInput(input);
+ assertEquals("Width should be 40", BigDecimal.valueOf(40), spectrumInformation.getWidth());
+ assertEquals("Wavelength should be 1", Uint32.valueOf(1), spectrumInformation.getWaveLength());
+ assertEquals("Center freq should be 196.1", BigDecimal.valueOf(196.1).setScale(4),
+ spectrumInformation.getCenterFrequency());
+ assertEquals("Lower slot number should be 761", 761, spectrumInformation.getLowerSpectralSlotNumber());
+ assertEquals("Higher slot number should be 768", 768, spectrumInformation.getHigherSpectralSlotNumber());
+ assertEquals("Min freq should be 196.075", BigDecimal.valueOf(196.075).setScale(4),
+ spectrumInformation.getMinFrequency());
+ assertEquals("Max freq should be 196.125", BigDecimal.valueOf(196.125).setScale(4),
+ spectrumInformation.getMaxFrequency());
+ }
+
+ @Test
+ public void initSpectrumInformationFromServicePathInputNoFreqTest() {
+ ServicePathInput input = new ServicePathInputBuilder()
+ .setWaveNumber(Uint32.valueOf(1))
+ .setHigherSpectralSlotNumber(Uint32.valueOf(768))
+ .setLowerSpectralSlotNumber(Uint32.valueOf(761))
+ .setWidth(new org.opendaylight.yang.gen.v1.http.org.openroadm.common.types.rev181019
+ .FrequencyGHz(GridConstant.WIDTH_40))
+ .build();
+ SpectrumInformation spectrumInformation = GridUtils.initSpectrumInformationFromServicePathInput(input);
+ assertEquals("Width should be 40", BigDecimal.valueOf(40), spectrumInformation.getWidth());
+ assertEquals("Wavelength should be 1", Uint32.valueOf(1), spectrumInformation.getWaveLength());
+ assertEquals("Center freq should be 196.1", BigDecimal.valueOf(196.1).setScale(4),
+ spectrumInformation.getCenterFrequency());
+ assertEquals("Lower slot number should be 761", 761, spectrumInformation.getLowerSpectralSlotNumber());
+ assertEquals("Higher slot number should be 768", 768, spectrumInformation.getHigherSpectralSlotNumber());
+ assertEquals("Min freq should be 196.075", BigDecimal.valueOf(196.075).setScale(4),
+ spectrumInformation.getMinFrequency());
+ assertEquals("Max freq should be 196.125", BigDecimal.valueOf(196.125).setScale(4),
+ spectrumInformation.getMaxFrequency());
+ }
+
+ @Test(expected = IllegalArgumentException.class)
+ public void initSpectrumInformationFromServicePathInputNoSlotTest() {
+ GridUtils.initSpectrumInformationFromServicePathInput(new ServicePathInputBuilder().build());
+ }
}
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl121;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
-import org.opendaylight.transportpce.common.fixedflex.FlexGridImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
import org.opendaylight.transportpce.common.mapping.PortMapping;
private OpenRoadmInterfaceFactory initOpenRoadmFactory(MappingUtils mappingUtils,
OpenRoadmInterfaces openRoadmInterfaces, PortMapping portMapping) {
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping, openRoadmInterfaces);
- OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping, openRoadmInterfaces,
- new FixedFlexImpl(), new FlexGridImpl());
+ OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping, openRoadmInterfaces);
OpenRoadmOtnInterface221 openRoadmOtnInterface221 = new OpenRoadmOtnInterface221(portMapping,
openRoadmInterfaces);
return new OpenRoadmInterfaceFactory(mappingUtils, openRoadmInterface121, openRoadmInterface221,
private TpceNetwork tpceNetwork;
private ListenerRegistration<TransportpceServicehandlerListener> serviceHandlerListenerRegistration;
private NotificationService notificationService;
- private FrequenciesService networkModelWavelengthService;
+ private FrequenciesService frequenciesService;
public NetworkModelProvider(NetworkTransactionService networkTransactionService, final DataBroker dataBroker,
final RpcProviderService rpcProviderService, final TransportpceNetworkutilsService networkutilsService,
final NetConfTopologyListener topologyListener, NotificationService notificationService,
- FrequenciesService networkModelWavelengthService) {
+ FrequenciesService frequenciesService) {
this.dataBroker = dataBroker;
this.rpcProviderService = rpcProviderService;
this.networkutilsService = networkutilsService;
this.topologyListener = topologyListener;
this.tpceNetwork = new TpceNetwork(networkTransactionService);
this.notificationService = notificationService;
- this.networkModelWavelengthService = networkModelWavelengthService;
+ this.frequenciesService = frequenciesService;
}
/**
networkutilsServiceRpcRegistration =
rpcProviderService.registerRpcImplementation(TransportpceNetworkutilsService.class, networkutilsService);
TransportpceServicehandlerListener serviceHandlerListner =
- new ServiceHandlerListener(networkModelWavelengthService);
+ new ServiceHandlerListener(frequenciesService);
serviceHandlerListenerRegistration = notificationService.registerNotificationListener(serviceHandlerListner);
}
}
/**
- * Allocate wavelength in topology.
+ * Allocate frequencies in topology.
* @param notification ServiceRpcResultSh
*/
private void onServiceCreation(ServiceRpcResultSh notification) {
}
/**
- * Release wavelength in topology.
+ * Release frequencies in topology.
* @param notification ServiceRpcResultSh
*/
private void onServiceDeletion(ServiceRpcResultSh notification) {
@Mock
private NotificationService notificationService;
@Mock
- private FrequenciesService networkModelWavelengthService;
+ private FrequenciesService frequenciesService;
@Test
public void networkmodelProviderInitTest() {
NetworkModelProvider provider = new NetworkModelProvider(networkTransactionService, getDataBroker(),
rpcProviderService, networkutilsService, topologyListener, notificationService,
- networkModelWavelengthService);
+ frequenciesService);
Answer<FluentFuture<CommitInfo>> answer = new Answer<FluentFuture<CommitInfo>>() {
@Override
pceResult.setLocalCause(PceResult.LocalCause.NO_PATH_EXISTS);
return pceResult;
}
- //TODO: until change to manage connection name, logical connection point name and service path
- // keep set wavelength number
- pceResult.setResultWavelength(
- GridUtils.getWaveLengthIndexFromSpectrumAssigment(spectrumAssignment.getBeginIndex()));
+ if (spectrumAssignment.isFlexGrid()) {
+ LOG.info("Spectrum assignment flexgrid mode");
+ pceResult.setResultWavelength(GridConstant.IRRELEVANT_WAVELENGTH_NUMBER);
+ } else {
+ LOG.info("Spectrum assignment fixedgrid mode");
+ pceResult.setResultWavelength(
+ GridUtils.getWaveLengthIndexFromSpectrumAssigment(spectrumAssignment.getBeginIndex()));
+ }
pceResult.setMinFreq(GridUtils.getStartFrequencyFromIndex(spectrumAssignment.getBeginIndex()));
pceResult.setMaxFreq(GridUtils.getStopFrequencyFromIndex(spectrumAssignment.getStopIndex()));
LOG.info("In PostAlgoPathValidator: spectrum assignment found {} {}", spectrumAssignment, path);
}
if (!pceNode.isValid()) {
- LOG.error("validateNode : there are no availaible wavelengths in node {}", pceNode.getNodeId().getValue());
+ LOG.error("validateNode : there are no available frequencies in node {}", pceNode.getNodeId().getValue());
return false;
}
return true;
public static ServicePathInputData rendererCreateServiceInputAToZ(String serviceName,
PathDescription pathDescription) {
+ int scale = GridConstant.FIXED_GRID_FREQUENCY_PRECISION;
AToZDirection atoZDirection = pathDescription.getAToZDirection();
LOG.info("Building ServicePathInputData for a to z direction {}", atoZDirection);
NodeLists nodeLists = getNodesListAToZ(atoZDirection.nonnullAToZ().values().iterator());
servicePathInputBuilder
.setWaveNumber(atoZDirection.getAToZWavelengthNumber());
}
+ if (Uint32.valueOf(GridConstant.IRRELEVANT_WAVELENGTH_NUMBER)
+ .equals(atoZDirection.getAToZWavelengthNumber())) {
+ scale = GridConstant.FLEX_GRID_FREQUENCY_PRECISION;
+ }
if (atoZDirection.getAToZMinFrequency() != null) {
servicePathInputBuilder.setMinFreq(new FrequencyTHz(atoZDirection.getAToZMinFrequency().getValue()));
servicePathInputBuilder.setLowerSpectralSlotNumber(Uint32
if (atoZDirection.getAToZMinFrequency() != null && atoZDirection.getAToZMaxFrequency() != null) {
servicePathInputBuilder.setCenterFreq(
GridUtils.getCentralFrequencyWithPrecision(atoZDirection.getAToZMinFrequency().getValue(),
- atoZDirection.getAToZMaxFrequency().getValue(), GridConstant.FREQUENCY_PRECISION));
+ atoZDirection.getAToZMaxFrequency().getValue(), scale));
}
if (atoZDirection.getRate() != null && atoZDirection.getModulationFormat() != null) {
Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
public static ServicePathInputData rendererCreateServiceInputZToA(String serviceName,
PathDescription pathDescription) {
+ int scale = GridConstant.FIXED_GRID_FREQUENCY_PRECISION;
ZToADirection ztoADirection = pathDescription.getZToADirection();
LOG.info("Building ServicePathInputData for z to a direction {}", ztoADirection);
NodeLists nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
servicePathInputBuilder
.setWaveNumber(ztoADirection.getZToAWavelengthNumber());
}
+ if (Uint32.valueOf(GridConstant.IRRELEVANT_WAVELENGTH_NUMBER)
+ .equals(ztoADirection.getZToAWavelengthNumber())) {
+ scale = GridConstant.FLEX_GRID_FREQUENCY_PRECISION;
+ }
if (ztoADirection.getZToAMinFrequency() != null) {
servicePathInputBuilder.setMinFreq(new FrequencyTHz(ztoADirection.getZToAMinFrequency().getValue()));
servicePathInputBuilder.setLowerSpectralSlotNumber(Uint32
if (ztoADirection.getZToAMinFrequency() != null && ztoADirection.getZToAMaxFrequency() != null) {
servicePathInputBuilder.setCenterFreq(
GridUtils.getCentralFrequencyWithPrecision(ztoADirection.getZToAMinFrequency().getValue(),
- ztoADirection.getZToAMaxFrequency().getValue(), GridConstant.FREQUENCY_PRECISION));
+ ztoADirection.getZToAMaxFrequency().getValue(), scale));
}
if (ztoADirection.getRate() != null && ztoADirection.getModulationFormat() != null) {
Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
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.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
return oduInterfaceBldr.getName();
}
/**
- * This methods creates an OCH interface on the given termination point on
+ * This methods creates a list of OCH interface on the given termination point on
* Roadm.
*
* @param nodeId node ID
* @param logicalConnPoint logical connection point
- * @param waveNumber wavelength number of the OCH interface.
- * @param lowerSpectralSlotNumber int
- * @param higherSpectralSlotNumber int
- * @return Name of the interface if successful, otherwise return null.
+ * @param spectrumInformation SpectrumInformation
+ * @return List containing name of the interface if successful, otherwise return empty list.
*
* @throws OpenRoadmInterfaceException OpenRoadm interface exception
*/
- public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ public List<String> createOpenRoadmOchInterfaces(String nodeId, String logicalConnPoint,
+ SpectrumInformation spectrumInformation)
throws OpenRoadmInterfaceException {
Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
"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, spectralSlotName));
+ spectrumInformation.getIdentifierFromParams(logicalConnPoint));
// OCH interface specific data
- OchBuilder ocIfBuilder = new OchBuilder().setWavelengthNumber(Uint32.valueOf(waveNumber));
+ OchBuilder ocIfBuilder = new OchBuilder().setWavelengthNumber(spectrumInformation.getWaveLength());
// Add supporting OMS interface
if (portMap.getSupportingOms() != null) {
return interfacesCreated;
}
- public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- OchAttributes.ModulationFormat format, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
- throws OpenRoadmInterfaceException {
+ public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
+ SpectrumInformation spectrumInformation) 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));
+ OchAttributes.ModulationFormat modulationFormat = OchAttributes.ModulationFormat.DpQpsk;
+ Optional<OchAttributes.ModulationFormat> optionalModulationFormat = OchAttributes.ModulationFormat
+ .forName(spectrumInformation.getModulationFormat());
+ if (optionalModulationFormat.isPresent()) {
+ modulationFormat = optionalModulationFormat.get();
+ }
// OCH interface specific data
OchBuilder ocIfBuilder = new OchBuilder()
- .setWavelengthNumber(Uint32.valueOf(waveNumber))
- .setModulationFormat(format)
+ .setWavelengthNumber(spectrumInformation.getWaveLength())
+ .setModulationFormat(modulationFormat)
.setRate(R100G.class)
.setTransmitPower(new PowerDBm(new BigDecimal("-5")));
.interfaces.rev161014.Interface1Builder();
// Create generic interface
InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
- createOpenRoadmOchInterfaceName(logicalConnPoint, spectralSlotName));
+ spectrumInformation.getIdentifierFromParams(logicalConnPoint));
ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
// Post interface on the device
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.FixedFlexInterface;
-import org.opendaylight.transportpce.common.fixedflex.FlexGridInterface;
import org.opendaylight.transportpce.common.fixedflex.GridConstant;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
"Unable to get mapping from PortMapping for node % and logical connection port %s";
private final PortMapping portMapping;
private final OpenRoadmInterfaces openRoadmInterfaces;
- private FixedFlexInterface fixedFlex;
- private FlexGridInterface flexGrid;
private static final Logger LOG = LoggerFactory.getLogger(OpenRoadmInterface221.class);
- public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces,
- FixedFlexInterface fixedFlex, FlexGridInterface flexGrid) {
+ public OpenRoadmInterface221(PortMapping portMapping, OpenRoadmInterfaces openRoadmInterfaces) {
this.portMapping = portMapping;
this.openRoadmInterfaces = openRoadmInterfaces;
- this.fixedFlex = fixedFlex;
- this.flexGrid = flexGrid;
}
public String createOpenRoadmEthInterface(String nodeId, String logicalConnPoint)
return ethInterfaceBldr.getName();
}
- public List<String> createFlexOCH(String nodeId, String logicalConnPoint, BigDecimal centerFreq,
- BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ public List<String> createFlexOCH(String nodeId, String logicalConnPoint, SpectrumInformation spectrumInformation)
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,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, spectrumInformation);
interfacesCreated.add(mcInterfaceCreated);
}
- String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, centerFreq, width,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ String mcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, spectrumInformation);
interfacesCreated.add(mcInterfaceCreated);
return interfacesCreated;
}
- /**
- * This methods creates an OCH interface on the given termination point on
- * Roadm.
- *
- * @param nodeId node ID
- * @param logicalConnPoint logical connection point
- * @param waveNumber wavelength number of the OCH interface.
- * @param 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,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
- throws OpenRoadmInterfaceException {
- Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
- if (portMap == null) {
- throw new OpenRoadmInterfaceException(
- String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
- }
-
- List<String> interfacesCreated = new ArrayList<>();
-
- if (logicalConnPoint.contains("DEG")) {
- String mcInterfaceCreated = createMCInterface(nodeId, logicalConnPoint, waveNumber,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
- interfacesCreated.add(mcInterfaceCreated);
- }
- String nmcInterfaceCreated = createNMCInterface(nodeId, logicalConnPoint, waveNumber,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
- interfacesCreated.add(nmcInterfaceCreated);
- return interfacesCreated;
- }
-
-
- public String createMCInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
- throws OpenRoadmInterfaceException {
-
- // TODO : Check this method
-
- fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
-
- Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
- if (portMap == null) {
- throw new OpenRoadmInterfaceException(
- String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
- }
-
- // TODO : Check this method
- String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
- String.valueOf(lowerSpectralSlotNumber),
- String.valueOf(higherSpectralSlotNumber));
- InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
- MediaChannelTrailTerminationPoint.class, String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
- logicalConnPoint,"mc",
- spectralSlotName))
- .setSupportingInterface(portMap.getSupportingOms());
-
- McTtpBuilder mcTtpBuilder = new McTtpBuilder()
- .setMinFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStart())))
- .setMaxFreq(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getStop())));
-
- // Create Interface1 type object required for adding as augmentation
- org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
- interface1Builder =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
- .setMcTtp(mcTtpBuilder.build());
-
- mcInterfaceBldr.addAugmentation(interface1Builder.build());
-
- // Post interface on the device
- openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
- return mcInterfaceBldr.getName();
- }
-
public String createMCInterface(String nodeId, String logicalConnPoint,
- BigDecimal centerFrequency, BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ SpectrumInformation spectrumInformation)
throws OpenRoadmInterfaceException {
-
- // TODO : Check this method
- flexGrid = flexGrid.getFlexWaveMapping(centerFrequency.floatValue(),
- GridConstant.WIDTH_SLOT_WIDTH_MAP.get(width).floatValue());
-
Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
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);
+ spectrumInformation.getMinFrequency(), spectrumInformation.getMaxFrequency(),
+ spectrumInformation.getCenterFrequency());
InterfaceBuilder mcInterfaceBldr = createGenericInterfaceBuilder(portMap,
- MediaChannelTrailTerminationPoint.class, String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
- logicalConnPoint, "mc", spectralSlotName))
+ MediaChannelTrailTerminationPoint.class,
+ spectrumInformation.getIdentifierFromParams(logicalConnPoint, "mc"))
.setSupportingInterface(portMap.getSupportingOms());
McTtpBuilder mcTtpBuilder = new McTtpBuilder()
- .setMinFreq(FrequencyTHz.getDefaultInstance(String.valueOf(flexGrid.getStart())))
- .setMaxFreq(FrequencyTHz.getDefaultInstance(String.valueOf(flexGrid.getStop())));
+ .setMinFreq(new FrequencyTHz(spectrumInformation.getMinFrequency()))
+ .setMaxFreq(new FrequencyTHz(spectrumInformation.getMaxFrequency()));
// Create Interface1 type object required for adding as augmentation
org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder
return mcInterfaceBldr.getName();
}
- public String createNMCInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
- throws OpenRoadmInterfaceException {
-
- // TODO : Check this method
- fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
-
- Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
- if (portMap == null) {
- throw new OpenRoadmInterfaceException(
- String.format(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, String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
- logicalConnPoint, "nmc", spectralSlotName));
- if (logicalConnPoint.contains("DEG")) {
- nmcInterfaceBldr.setSupportingInterface(String.join(GridConstant.NAME_PARAMETERS_SEPARATOR,
- logicalConnPoint, "mc", spectralSlotName));
- }
-
- NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
- .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())))
- .setWidth(FrequencyGHz.getDefaultInstance("40"));
-
- // Create Interface1 type object required for adding as augmentation
- org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
- nmcCtpI1fBuilder =
- new org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019
- .Interface1Builder().setNmcCtp(nmcCtpIfBuilder.build());
- nmcInterfaceBldr.addAugmentation(nmcCtpI1fBuilder.build());
-
- // Post interface on the device
- openRoadmInterfaces.postInterface(nodeId, nmcInterfaceBldr);
- return nmcInterfaceBldr.getName();
- }
-
public String createNMCInterface(String nodeId, String logicalConnPoint,
- BigDecimal centerFrequency, BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ SpectrumInformation spectrumInformation)
throws OpenRoadmInterfaceException {
- LOG.info("This is the central frequency {}", centerFrequency.floatValue());
- LOG.info("This is the nmc width {}", width.floatValue());
+ LOG.info("This is the central frequency {}", spectrumInformation.getCenterFrequency());
+ LOG.info("This is the nmc width {}", spectrumInformation.getWidth());
// TODO : Check this method
Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
if (portMap == null) {
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);
+ String nmcName = spectrumInformation.getIdentifierFromParams(logicalConnPoint, "nmc");
InterfaceBuilder nmcInterfaceBldr = createGenericInterfaceBuilder(portMap,
NetworkMediaChannelConnectionTerminationPoint.class, nmcName);
if (logicalConnPoint.contains("DEG")) {
}
NmcCtpBuilder nmcCtpIfBuilder = new NmcCtpBuilder()
- .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)))
- .setWidth(new FrequencyGHz(width));
+ .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
+ .setWidth(new FrequencyGHz(spectrumInformation.getWidth()));
// Create Interface1 type object required for adding as augmentation
org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1Builder
return nmcInterfaceBldr.getName();
}
- public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
- throws OpenRoadmInterfaceException {
- // TODO : Check this method
-
- fixedFlex = fixedFlex.getFixedFlexWaveMapping(waveNumber.shortValue());
-
- Mapping portMap = portMapping.getMapping(nodeId, logicalConnPoint);
- if (portMap == null) {
- throw new OpenRoadmInterfaceException(
- String.format(MAPPING_ERROR_EXCEPTION_MESSAGE, nodeId, logicalConnPoint));
- }
-
- // OCH interface specific data
- OchBuilder ocIfBuilder = new OchBuilder()
- .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(fixedFlex.getCenterFrequency())))
- .setRate(R100G.class)
- // 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, 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
- ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019
- .Interface1Builder();
- ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
-
- // Post interface on the device
- openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
-
- // Post the equipment-state change on the device circuit-pack if xpdr node
- if (portMap.getLogicalConnectionPoint().contains(StringConstants.NETWORK_TOKEN)) {
- this.openRoadmInterfaces.postEquipmentState(nodeId, portMap.getSupportingCircuitPackName(), true);
- }
-
- return ochInterfaceBldr.getName();
- }
-
public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
- BigDecimal centerFrequency, int lowerSpectralSlotNumber, int higherSpectralSlotNumber, String format)
+ SpectrumInformation spectrumInformation)
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);
+ Optional<ModulationFormat> optionalModulationFormat = ModulationFormat
+ .forName(spectrumInformation.getModulationFormat());
if (optionalModulationFormat.isPresent()) {
modulationFormat = optionalModulationFormat.get();
}
// OCH interface specific data
OchBuilder ocIfBuilder = new OchBuilder()
- .setFrequency(FrequencyTHz.getDefaultInstance(String.valueOf(centerFrequency)))
+ .setFrequency(new FrequencyTHz(spectrumInformation.getCenterFrequency()))
.setRate(R100G.class)
.setTransmitPower(new PowerDBm(new BigDecimal("-5")))
.setModulationFormat(modulationFormat);
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, spectralSlotName));
+ spectrumInformation.getIdentifierFromParams(logicalConnPoint));
// 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
package org.opendaylight.transportpce.renderer.openroadminterface;
-import java.math.BigDecimal;
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.fixedflex.SpectrumInformation;
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;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
}
}
- public List<String> createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- BigDecimal centerFreq, BigDecimal width, int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
+ public List<String> createOpenRoadmOchInterfaces(String nodeId, String logicalConnPoint,
+ SpectrumInformation spectrumInformation)
throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ return openRoadmInterface121.createOpenRoadmOchInterfaces(nodeId, logicalConnPoint,
+ spectrumInformation);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, centerFreq,
- width, lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation);
default:
return null;
}
}
+
/**
- * This methods creates an OCH interface on the given termination point on
- * Roadm.
+ * This methods creates an OCH interface on the given termination point on Roadm.
*
* @param nodeId node ID
* @param logicalConnPoint logical connection point
- * @param waveNumber wavelength number of the OCH interface.
- * @param lowerSpectralSlotNumber int
- * @param higherSpectralSlotNumber int
+ * @param spectrumInformation spectrum information.
* @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,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber)
- throws OpenRoadmInterfaceException {
+ public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint,
+ SpectrumInformation spectrumInformation) throws OpenRoadmInterfaceException {
switch (mappingUtils.getOpenRoadmVersion(nodeId)) {
case StringConstants.OPENROADM_DEVICE_VERSION_1_2_1:
- return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
+ return openRoadmInterface121.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
+ spectrumInformation);
case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
- default:
- return null;
- }
- }
+ return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
+ spectrumInformation);
- public String createOpenRoadmOchInterface(String nodeId, String logicalConnPoint, Long waveNumber,
- 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,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
- case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- 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, 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,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
- case StringConstants.OPENROADM_DEVICE_VERSION_2_2_1:
- return openRoadmInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
- lowerSpectralSlotNumber, higherSpectralSlotNumber);
default:
return null;
}
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.FluentFuture;
-import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
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.fixedflex.GridUtils;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev200128.renderer.rollback.output.FailedToRollbackKey;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.Mapping;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.Topology;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.OchAttributes.ModulationFormat;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.ServiceList;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.Services;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.ServicesBuilder;
if (input.getNodes() != null) {
nodes.addAll(input.getNodes());
}
+ SpectrumInformation spectrumInformation = GridUtils.initSpectrumInformationFromServicePathInput(input);
// Register node for suppressing alarms
if (!alarmSuppressionNodeRegistration(input)) {
LOG.warn("Alarm suppresion node registration failed!!!!");
try {
// if the node is currently mounted then proceed
if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
- 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;
- if (input.getCenterFreq() != null) {
- centerFreq = input.getCenterFreq().getValue();
- }
- if (input.getWidth() != null) {
- width = input.getWidth().getValue();
- }
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);
+ LOG.info("Adding supporting OCH interface for node {}, dest tp {}, spectrumInformation {}",
+ nodeId, destTp, spectrumInformation);
crossConnectFlag++;
- String supportingOchInterface;
- if ((centerFreq != null) && (width != null)) {
- supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, destTp, waveNumber, modulationFormat, centerFreq, lowerSpectralSlotNumber,
- higherSpectralSlotNumber);
- }
- else {
- supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, destTp, waveNumber, modulationFormat, lowerSpectralSlotNumber,
- higherSpectralSlotNumber);
- }
+ String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
+ nodeId, destTp, spectrumInformation);
createdOchInterfaces.add(supportingOchInterface);
// Here we pass logical connection-point of z-end to set SAPI and DAPI
Nodes tgtNode = null;
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);
+ LOG.info("Adding supporting OCH interface for node {}, src tp {}, spectrumInformation {}",
+ nodeId, srcTp, spectrumInformation);
crossConnectFlag++;
// create OpenRoadm Xponder Line Interfaces
- String supportingOchInterface;
- if ((centerFreq != null) && (width != null)) {
- supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, srcTp, waveNumber, modulationFormat, centerFreq, lowerSpectralSlotNumber,
- higherSpectralSlotNumber);
- }
- else {
- supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
- nodeId, srcTp, waveNumber,modulationFormat, lowerSpectralSlotNumber,
- higherSpectralSlotNumber);
- }
+ String supportingOchInterface = this.openRoadmInterfaceFactory.createOpenRoadmOchInterface(
+ nodeId, srcTp, spectrumInformation);
createdOchInterfaces.add(supportingOchInterface);
String supportingOtuInterface = this.openRoadmInterfaceFactory
.createOpenRoadmOtu4Interface(nodeId, srcTp, supportingOchInterface);
}
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,
- lowerSpectralSlotNumber, higherSpectralSlotNumber));
- }
- else {
- createdOchInterfaces.addAll(
- this.openRoadmInterfaceFactory
- .createOpenRoadmOchInterface(nodeId, srcTp, waveNumber, lowerSpectralSlotNumber,
- higherSpectralSlotNumber));
- }
+ LOG.info("Adding supporting OCH interface for node {}, src tp {}, spectrumInformation {}",
+ nodeId, srcTp, spectrumInformation);
+ createdOchInterfaces.addAll(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaces(nodeId,
+ srcTp, spectrumInformation));
}
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,
- lowerSpectralSlotNumber, higherSpectralSlotNumber));
- }
- else {
- createdOchInterfaces.addAll(
- this.openRoadmInterfaceFactory
- .createOpenRoadmOchInterface(nodeId, destTp, waveNumber, lowerSpectralSlotNumber,
- higherSpectralSlotNumber));
- }
-
+ LOG.info("Adding supporting OCH interface for node {}, dest tp {}, spectrumInformation {}",
+ nodeId, destTp, spectrumInformation);
+ createdOchInterfaces.addAll(this.openRoadmInterfaceFactory.createOpenRoadmOchInterfaces(nodeId,
+ destTp, spectrumInformation));
}
if (crossConnectFlag < 1) {
LOG.info("Creating cross connect between source {} and destination {} for node {}", srcTp,
destTp, nodeId);
Optional<String> connectionNameOpt =
- this.crossConnect.postCrossConnect(nodeId, waveNumber, srcTp, destTp,
- lowerSpectralSlotNumber,
- higherSpectralSlotNumber);
+ this.crossConnect.postCrossConnect(nodeId, srcTp, destTp, spectrumInformation);
if (connectionNameOpt.isPresent()) {
nodesProvisioned.add(nodeId);
createdConnections.add(connectionNameOpt.get());
LOG.info("Deleting service setup on node {}", nodeId);
String srcTp;
String destTp;
- Long waveNumber = input.getWaveNumber().toJava();
if (node.getDestTp() == null) {
LOG.error("Destination termination point must not be null.");
return;
}
// 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,
input.getLowerSpectralSlotNumber().intValue(),
input.getHigherSpectralSlotNumber().intValue()));
} else {
}
private List<String> getInterfaces2delete(
- String nodeId, String srcTp, String destTp, Long waveNumber,
- int lowerSpectralSlotNumber, int higherSpectralSlotNumber) {
+ String nodeId, String srcTp, String destTp, int lowerSpectralSlotNumber, int higherSpectralSlotNumber) {
String spectralSlotName = String.join(GridConstant.SPECTRAL_SLOT_SEPARATOR,
String.valueOf(lowerSpectralSlotNumber),
String.valueOf(higherSpectralSlotNumber));
<reference id="portMapping" interface="org.opendaylight.transportpce.common.mapping.PortMapping" />
<reference id="crossConnect" interface="org.opendaylight.transportpce.common.crossconnect.CrossConnect" />
<reference id="mappingUtils" interface="org.opendaylight.transportpce.common.mapping.MappingUtils"/>
- <reference id="FixedFlexImpl" interface="org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface"/>
<reference id="networkModelService" interface="org.opendaylight.transportpce.networkmodel.service.NetworkModelService"/>
- <reference id="FlexGridImpl" interface="org.opendaylight.transportpce.common.fixedflex.FlexGridInterface"/>
<odl:rpc-service id="olmService"
interface="org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev170418.TransportpceOlmService"/>
class="org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterface221">
<argument ref="portMapping"/>
<argument ref="openRoadmInterfaces"/>
- <argument ref="FixedFlexImpl"/>
- <argument ref="FlexGridImpl"/>
</bean>
<bean id="openRoadmOtnInterface"
import org.junit.Ignore;
import org.junit.Test;
import org.mockito.Mockito;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface;
-import org.opendaylight.transportpce.common.fixedflex.FlexGridImpl;
+import org.opendaylight.transportpce.common.fixedflex.SpectrumInformation;
import org.opendaylight.transportpce.common.mapping.PortMapping;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev201012.network.nodes.MappingBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
@Ignore
public class OpenRoadMInterface221Test extends AbstractTest {
private final PortMapping portMapping = Mockito.mock(PortMapping.class);
- private final FixedFlexInterface fixedFlex = Mockito.spy(FixedFlexInterface.class);
- private final FlexGridImpl flexGrid = Mockito.spy(FlexGridImpl.class);
private OpenRoadmInterface221 openRoadMInterface221;
private final String nodeId = "node1";
public void setup() {
OpenRoadmInterfaces openRoadmInterfaces = Mockito.spy(OpenRoadmInterfaces.class);
- this.openRoadMInterface221 = new OpenRoadmInterface221(portMapping, openRoadmInterfaces, fixedFlex, flexGrid);
+ this.openRoadMInterface221 = new OpenRoadmInterface221(portMapping, openRoadmInterfaces);
}
@Test
String logicalConnPoint = "logicalConnPoint";
Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint)).thenReturn(new MappingBuilder().build());
- Mockito.when(fixedFlex.getFixedFlexWaveMapping(Mockito.anyLong())).thenReturn(new FixedFlexImpl());
- Mockito.when(fixedFlex.getStart()).thenReturn(12d);
- Mockito.when(fixedFlex.getStop()).thenReturn(12d);
- Mockito.when(fixedFlex.getCenterFrequency()).thenReturn(12d);
- Long waveNumber = 1L;
- Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber, 761, 768));
- Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, waveNumber, 761, 768),
+ SpectrumInformation spectrumInformation = new SpectrumInformation();
+ spectrumInformation.setWaveLength(Uint32.valueOf(1));
+ spectrumInformation.setLowerSpectralSlotNumber(761);
+ spectrumInformation.setHigherSpectralSlotNumber(768);
+ Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation));
+ Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
Arrays.asList(logicalConnPoint + "-nmc-761:768"));
}
String logicalConnPoint = "logicalConnPointDEG";
Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint)).thenReturn(new MappingBuilder().build());
- Mockito.when(fixedFlex.getFixedFlexWaveMapping(Mockito.anyLong())).thenReturn(new FixedFlexImpl());
- Mockito.when(fixedFlex.getStart()).thenReturn(12d);
- Mockito.when(fixedFlex.getStop()).thenReturn(12d);
- Mockito.when(fixedFlex.getCenterFrequency()).thenReturn(12d);
- 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"));
+ SpectrumInformation spectrumInformation = new SpectrumInformation();
+ spectrumInformation.setWaveLength(Uint32.valueOf(1));
+ spectrumInformation.setLowerSpectralSlotNumber(761);
+ spectrumInformation.setHigherSpectralSlotNumber(768);
+ Assert.assertNotNull(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint,spectrumInformation));
+ Assert.assertEquals(openRoadMInterface221.createFlexOCH(nodeId, logicalConnPoint, spectrumInformation),
+ Arrays.asList(logicalConnPoint + "-mc-761:768", logicalConnPoint + "-nmc-761:768"));
}
@Test
String logicalConnPoint = "logicalConnPoint";
Mockito.when(portMapping.getMapping(nodeId, logicalConnPoint))
.thenReturn(new MappingBuilder().setLogicalConnectionPoint(logicalConnPoint).build());
- Mockito.when(fixedFlex.getCenterFrequency()).thenReturn(12d);
- Mockito.when(fixedFlex.getFixedFlexWaveMapping(Mockito.anyLong())).thenReturn(new FixedFlexImpl());
- Long waveNumber = 1L;
- Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint, waveNumber,
- 761, 768), logicalConnPoint + "-761:768");
+ SpectrumInformation spectrumInformation = new SpectrumInformation();
+ spectrumInformation.setWaveLength(Uint32.valueOf(1));
+ spectrumInformation.setLowerSpectralSlotNumber(761);
+ spectrumInformation.setHigherSpectralSlotNumber(768);
+ Assert.assertEquals(openRoadMInterface221.createOpenRoadmOchInterface(nodeId, logicalConnPoint,
+ spectrumInformation), logicalConnPoint + "-761:768");
}
@Test
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface;
-import org.opendaylight.transportpce.common.fixedflex.FlexGridImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
import org.opendaylight.transportpce.common.mapping.PortMapping;
PortMapping portMapping =
new PortMappingImpl(getDataBroker(), this.portMappingVersion710, this.portMappingVersion22,
this.portMappingVersion121);
- FixedFlexInterface fixedFlexInterface = new FixedFlexImpl();
- FlexGridImpl flexGrid = new FlexGridImpl();
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
- OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces,
- fixedFlexInterface, flexGrid);
+ OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121,
openRoadmInterface221, openRoadmOTNInterface);
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface;
-import org.opendaylight.transportpce.common.fixedflex.FlexGridImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
import org.opendaylight.transportpce.common.mapping.PortMapping;
this.crossConnect = new CrossConnectImpl(deviceTransactionManager, this.mappingUtils, this.crossConnectImpl121,
this.crossConnectImpl221);
this.crossConnect = Mockito.spy(crossConnect);
- FixedFlexInterface fixedFlexInterface = new FixedFlexImpl();
- FlexGridImpl flexGrid = new FlexGridImpl();
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
- OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces,
- fixedFlexInterface, flexGrid);
+ OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
OpenRoadmInterfaceFactory openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,
openRoadmInterface121, openRoadmInterface221, openRoadmOTNInterface);
- this.deviceRenderer = new DeviceRendererServiceImpl(this.getDataBroker(),
+ this.deviceRenderer = new DeviceRendererServiceImpl(getDataBroker(),
this.deviceTransactionManager, openRoadmInterfaceFactory, openRoadmInterfaces, crossConnect,
this.portMapping, null);
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl221;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.device.DeviceTransactionManagerImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
-import org.opendaylight.transportpce.common.fixedflex.FixedFlexInterface;
-import org.opendaylight.transportpce.common.fixedflex.FlexGridImpl;
import org.opendaylight.transportpce.common.mapping.MappingUtils;
import org.opendaylight.transportpce.common.mapping.MappingUtilsImpl;
import org.opendaylight.transportpce.common.mapping.PortMapping;
new PortMappingVersion710(getDataBroker(), deviceTransactionManager, this.openRoadmInterfaces);
this.portMapping = new PortMappingImpl(getDataBroker(), this.portMappingVersion710, this.portMappingVersion22,
this.portMappingVersion121);
- FixedFlexInterface fixedFlexInterface = new FixedFlexImpl();
- FlexGridImpl flexGrid = new FlexGridImpl();
OpenRoadmInterface121 openRoadmInterface121 = new OpenRoadmInterface121(portMapping,openRoadmInterfaces);
- OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces,
- fixedFlexInterface, flexGrid);
+ OpenRoadmInterface221 openRoadmInterface221 = new OpenRoadmInterface221(portMapping,openRoadmInterfaces);
OpenRoadmOtnInterface221 openRoadmOTNInterface = new OpenRoadmOtnInterface221(portMapping, openRoadmInterfaces);
this.openRoadmInterfaceFactory = new OpenRoadmInterfaceFactory(this.mappingUtils,openRoadmInterface121,
openRoadmInterface221, openRoadmOTNInterface);
"transportpce-device-renderer:modulation-format": "dp-qpsk",
"transportpce-device-renderer:operation": "create",
"transportpce-device-renderer:service-name": "testNMC-MC",
- "transportpce-device-renderer:wave-number": "2",
+ "transportpce-device-renderer:wave-number": "0",
"transportpce-device-renderer:center-freq": "196.05",
"transportpce-device-renderer:width": "80",
"transportpce-device-renderer:nodes": [
"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
+ "transportpce-device-renderer:min-freq": 196.00625,
+ "transportpce-device-renderer:max-freq": 196.09375,
+ "transportpce-device-renderer:lower-spectral-slot-number": 749,
+ "transportpce-device-renderer:higher-spectral-slot-number": 763
}
}
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-741:754")
+ "interface/DEG1-TTP-TXRX-mc-749:763")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictEqual(
- dict({"name": "DEG1-TTP-TXRX-mc-741:754",
+ dict({"name": "DEG1-TTP-TXRX-mc-749:763",
"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-741:754")
+ "interface/DEG1-TTP-TXRX-nmc-749:763")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
self.assertDictEqual(
- dict({"name": "DEG1-TTP-TXRX-nmc-741:754",
- "supporting-interface": "DEG1-TTP-TXRX-mc-741:754",
+ dict({"name": "DEG1-TTP-TXRX-nmc-749:763",
+ "supporting-interface": "DEG1-TTP-TXRX-mc-749:763",
"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-741:754")
+ "interface/SRG1-PP1-TXRX-nmc-749:763")
res = response.json()
self.assertEqual(response.status_code, requests.codes.ok)
self.assertEqual(
- dict({"name": "SRG1-PP1-TXRX-nmc-741:754",
+ dict({"name": "SRG1-PP1-TXRX-nmc-749:763",
"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-741:754")
+ "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763")
self.assertEqual(response.status_code, requests.codes.ok)
res = response.json()
- self.assertEqual("SRG1-PP1-TXRX-DEG1-TTP-TXRX-741:754",
+ self.assertEqual("SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763",
res['roadm-connections'][0]['connection-name'])
- self.assertEqual("SRG1-PP1-TXRX-nmc-741:754",
+ self.assertEqual("SRG1-PP1-TXRX-nmc-749:763",
res['roadm-connections'][0]['source']['src-if'])
- self.assertEqual("DEG1-TTP-TXRX-nmc-741:754",
+ self.assertEqual("DEG1-TTP-TXRX-nmc-749:763",
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-741:754")
+ "roadm-connections/SRG1-PP1-TXRX-DEG1-TTP-TXRX-749:763")
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-741:754")
+ "interface/SRG1-PP1-TXRX-nmc-749:763")
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-741:754")
+ "interface/DEG1-TTP-TXRX-nmc-749:763")
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-741:754")
+ "interface/DEG1-TTP-TXRX-mc-749:763")
self.assertEqual(response.status_code, requests.codes.ok)
time.sleep(3)
Code Review / transportpce.git / commitdiff