*/
package org.opendaylight.transportpce.renderer;
-import com.google.common.base.Optional;
-
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
+import java.util.Optional;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;
-import org.opendaylight.controller.md.sal.binding.api.DataBroker;
-import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;
-import org.opendaylight.controller.md.sal.binding.api.WriteTransaction;
-import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
+import org.opendaylight.mdsal.binding.api.DataBroker;
+import org.opendaylight.mdsal.binding.api.ReadTransaction;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.NetworkUtils;
import org.opendaylight.transportpce.common.Timeouts;
import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
InstanceIdentifier<Node1>
nodeIID = createNode1IID(nodeId);
Optional<Node1> nodeOpt;
- try (ReadOnlyTransaction nodeReadTx = this.dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction nodeReadTx = this.dataBroker.newReadOnlyTransaction()) {
nodeOpt = nodeReadTx.read(LogicalDatastoreType.CONFIGURATION, nodeIID)
.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Exception while getting node from {} topology!", NetworkUtils.OVERLAY_NETWORK_ID, e);
- nodeOpt = Optional.absent();
+ nodeOpt = Optional.empty();
}
return nodeOpt;
}
Node1Builder node1Builder = new Node1Builder(node);
- switch (node.getNodeType()) {
+ switch (node1Builder.getNodeType()) {
case DEGREE:
DegreeAttributes degreeAttributes = node.getDegreeAttributes();
DegreeAttributesBuilder degreeAttributesBuilder;
nodeWriteTx.put(LogicalDatastoreType.CONFIGURATION, createNode1IID(nodeId), node1Builder.build(), true);
}
try {
- nodeWriteTx.submit().get(Timeouts.DATASTORE_DELETE, TimeUnit.MILLISECONDS);
+ nodeWriteTx.commit().get(Timeouts.DATASTORE_DELETE, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.error("Unable to add available WL {} for nodes {}!", wavelengthNumber, String.join(", ", nodeIds), e);
}
if (nodeOpt.isPresent()) {
node = nodeOpt.get();
} else {
- LOG.error("Unable to get node {} from topology {}! Skipping addition of available wavelength for this"
- + "node.", nodeId, NetworkUtils.OVERLAY_NETWORK_ID);
+ LOG.error(
+ "Unable to get node {} from topology {}! Skipping addition of available wavelength for this node.",
+ nodeId, NetworkUtils.OVERLAY_NETWORK_ID);
continue;
}
nodeWriteTx.delete(LogicalDatastoreType.CONFIGURATION, availableWlIID);
}
try {
- nodeWriteTx.submit().get(Timeouts.DATASTORE_DELETE, TimeUnit.MILLISECONDS);
+ nodeWriteTx.commit().get(Timeouts.DATASTORE_DELETE, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.error("Unable to delete available WL {} for nodes {}!", wavelengthNumber, String.join(", ", nodeIds),
e);
private Optional<TerminationPoint1> getTerminationPoint1FromDatastore(String nodeId, String tpId) {
InstanceIdentifier<TerminationPoint1> tpIID = createTerminationPoint1IIDBuilder(nodeId, tpId).build();
Optional<TerminationPoint1> tpOpt;
- try (ReadOnlyTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
+ try (ReadTransaction readTx = this.dataBroker.newReadOnlyTransaction()) {
tpOpt = readTx.read(LogicalDatastoreType.CONFIGURATION, tpIID)
.get(Timeouts.DATASTORE_READ, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
LOG.warn("Exception while getting termination point from {} topology!", NetworkUtils.OVERLAY_NETWORK_ID,
e);
- tpOpt = Optional.absent();
+ tpOpt = Optional.empty();
}
return tpOpt;
}
deleteUsedWlTx.delete(LogicalDatastoreType.CONFIGURATION, usedWlIID);
}
try {
- deleteUsedWlTx.submit().get(Timeouts.DATASTORE_DELETE, TimeUnit.MILLISECONDS);
+ deleteUsedWlTx.commit().get(Timeouts.DATASTORE_DELETE, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
List<String> tpIdsString = tpIds.stream().map(NodeIdPair::toString).collect(Collectors.toList());
LOG.error("Unable to delete used WL {} from TPs {}!", wavelengthIndex, String.join(", ", tpIdsString), e);
private void addUsedWL(long wavelengthIndex, List<NodeIdPair> tpIds) {
WriteTransaction addUsedWlTx = this.dataBroker.newWriteOnlyTransaction();
FixedFlexImpl fixedFlex = new FixedFlexImpl(wavelengthIndex);
- FrequencyGHz frequencyGHz = new FrequencyGHz(new BigDecimal(fixedFlex.getWavelength()));
- FrequencyTHz frequencyTHz = new FrequencyTHz(new BigDecimal(fixedFlex.getCenterFrequency()));
+ FrequencyTHz centralTHz = new FrequencyTHz(new BigDecimal(fixedFlex.getCenterFrequency()));
for (NodeIdPair idPair : tpIds) {
Optional<TerminationPoint1> tpOpt = getTerminationPoint1FromDatastore(idPair.getNodeID(), idPair.getTpID());
if (tpOpt.isPresent()) {
tp = tpOpt.get();
} else {
- LOG.error("Unable to get termination point {} from topology {}! Skipping removal of used wavelength"
- + " for this node.", idPair.getTpID(), NetworkUtils.OVERLAY_NETWORK_ID);
+ LOG.error(
+ "Unable to get termination point {} from topology {}! Skip removal of used wavelength for the node",
+ idPair.getTpID(), NetworkUtils.OVERLAY_NETWORK_ID);
continue;
}
usedDegreeTxTtpWls = new ArrayList<>();
txTtpAttributesBuilder.setUsedWavelengths(usedDegreeTxTtpWls);
}
- usedDegreeTxTtpWls.add(new UsedWavelengthsBuilder().setIndex(wavelengthIndex).build());
+ usedDegreeTxTtpWls.add(new UsedWavelengthsBuilder().setIndex(wavelengthIndex)
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
tp1Builder.setTxTtpAttributes(txTtpAttributesBuilder.build());
break;
usedDegreeRxTtpWls = new ArrayList<>();
rxTtpAttributesBuilder.setUsedWavelengths(usedDegreeRxTtpWls);
}
- usedDegreeRxTtpWls.add(new UsedWavelengthsBuilder().setIndex(wavelengthIndex).build());
+ usedDegreeRxTtpWls.add(new UsedWavelengthsBuilder().setIndex(wavelengthIndex)
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
tp1Builder.setRxTtpAttributes(rxTtpAttributesBuilder.build());
break;
usedDegreeCtpWls = new ArrayList<>();
ctpAttributesBuilder.setUsedWavelengths(usedDegreeCtpWls);
}
- usedDegreeCtpWls.add(new UsedWavelengthsBuilder().setIndex(wavelengthIndex).build());
+ usedDegreeCtpWls.add(new UsedWavelengthsBuilder().setIndex(wavelengthIndex)
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
tp1Builder.setCtpAttributes(ctpAttributesBuilder.build());
break;
}
usedDegreeCpWls.add(new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130
.networks.network.node.termination.point.cp.attributes.UsedWavelengthsBuilder()
- .setIndex(wavelengthIndex).build());
+ .setIndex(wavelengthIndex)
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
tp1Builder.setCpAttributes(cpAttributesBuilder.build());
break;
usedDegreePpWls = new ArrayList<>();
ppAttributesBuilder.setUsedWavelength(usedDegreePpWls);
}
- usedDegreePpWls.add(new UsedWavelengthBuilder().setIndex(wavelengthIndex).build());
+ usedDegreePpWls.add(new UsedWavelengthBuilder().setIndex(wavelengthIndex)
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
tp1Builder.setPpAttributes(ppAttributesBuilder.build());
break;
} else {
xpdrNetworkAttributesBuilder = new XpdrNetworkAttributesBuilder(xpdrNetworkAttributes);
}
- Wavelength usedXpdrNetworkWl = new WavelengthBuilder().setWidth(frequencyGHz)
- .setFrequency(frequencyTHz).build();
- tp1Builder.setXpdrNetworkAttributes(xpdrNetworkAttributesBuilder
- .setWavelength(usedXpdrNetworkWl)
- .build());
+ Wavelength usedXpdrNetworkWl = new WavelengthBuilder()
+ .setWidth(FrequencyGHz.getDefaultInstance("40")).setFrequency(centralTHz).build();
+ tp1Builder.setXpdrNetworkAttributes(xpdrNetworkAttributesBuilder.setWavelength(usedXpdrNetworkWl)
+ .build());
break;
case XPONDERCLIENT:
break;
} else {
xpdrPortAttributesBuilder = new XpdrPortAttributesBuilder(xpdrPortAttributes);
}
- Wavelength usedXpdrPortWl = new WavelengthBuilder().setWidth(frequencyGHz)
- .setFrequency(frequencyTHz).build();
- tp1Builder.setXpdrPortAttributes(xpdrPortAttributesBuilder
- .setWavelength(usedXpdrPortWl)
- .build());
+ Wavelength usedXpdrPortWl = new WavelengthBuilder().setWidth(FrequencyGHz.getDefaultInstance("40"))
+ .setFrequency(centralTHz).build();
+ tp1Builder.setXpdrPortAttributes(xpdrPortAttributesBuilder.setWavelength(usedXpdrPortWl)
+ .build());
break;
default:
idPair.getTpID()).build(), tp1Builder.build(), true);
}
try {
- addUsedWlTx.submit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
+ addUsedWlTx.commit().get(Timeouts.DATASTORE_WRITE, TimeUnit.MILLISECONDS);
} catch (InterruptedException | ExecutionException | TimeoutException e) {
List<String> tpIdsString = tpIds.stream().map(NodeIdPair::toString).collect(Collectors.toList());
LOG.error("Unable to add used WL {} for TPs {}!", wavelengthIndex, String.join(", ", tpIdsString), e);