public static ServicePathInputData rendererCreateServiceInputAToZ(String serviceName,
PathDescription pathDescription) {
- NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().getAToZ().iterator());
+ NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().nonnullAToZ().values().iterator());
ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
.setServiceName(serviceName)
.setOperation(ServicePathInput.Operation.Create)
public static ServicePathInputData rendererCreateServiceInputZToA(String serviceName,
PathDescription pathDescription) {
- NodeLists nodeLists = getNodesListZtoA(pathDescription.getZToADirection().getZToA().iterator());
+ NodeLists nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
.setOperation(ServicePathInput.Operation.Create)
.setServiceName(serviceName)
// If atoZ is set true use A-to-Z direction otherwise use Z-to-A
List<org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input.Nodes> nodes =
new ArrayList<>();
- NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().getAToZ().iterator());
+ NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().nonnullAToZ().values().iterator());
if (!asideToZside) {
- nodeLists = getNodesListZtoA(pathDescription.getZToADirection().getZToA().iterator());
+ nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
}
LOG.info("These are node-lists {}, {}", nodeLists.getList(), nodeLists.getOlmList());
for (Nodes node: nodeLists.getList()) {
package org.opendaylight.transportpce.renderer;
import java.math.BigDecimal;
-import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.concurrent.ExecutionException;
import org.opendaylight.transportpce.common.fixedflex.FixedFlexImpl;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev181130.FrequencyGHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev181130.FrequencyTHz;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengths;
import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengthsKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.used.wavelengths.UsedWavelengths;
import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.used.wavelengths.UsedWavelengthsBuilder;
@Override
public void useWavelengths(PathDescription pathDescription) {
-
List<NodeIdPair> atozTpIds = getAToZTpList(pathDescription);
atozTpIds.removeIf(Objects::isNull);
deleteAvailableWL(atozTpIds.stream().map(NodeIdPair::getNodeID).distinct().collect(Collectors.toList()),
}
private List<NodeIdPair> getAToZTpList(PathDescription pathDescription) {
- List<AToZ> atozList = pathDescription.getAToZDirection().getAToZ();
+ Collection<AToZ> atozList = pathDescription.getAToZDirection().nonnullAToZ().values();
return atozList.stream()
.filter(aToZ -> {
if ((aToZ.getResource() == null) || (aToZ.getResource().getResource() == null)) {
}
private List<NodeIdPair> getZToATpList(PathDescription pathDescription) {
- List<ZToA> ztoaList = pathDescription.getZToADirection().getZToA();
+ Collection<ZToA> ztoaList = pathDescription.getZToADirection().nonnullZToA().values();
return ztoaList.stream()
.filter(zToA -> {
if ((zToA.getResource() == null) || (zToA.getResource().getResource() == null)) {
} else {
degreeAttributesBuilder = new DegreeAttributesBuilder(degreeAttributes);
}
- List<org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes
- .AvailableWavelengths> availableDegreeWLs = new ArrayList<>(degreeAttributesBuilder
- .getAvailableWavelengths());
- availableDegreeWLs.add(new org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree
- .node.attributes.AvailableWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthNumber))
- .build());
+ Map<org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130
+ .degree.node.attributes.AvailableWavelengthsKey,
+ org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130
+ .degree.node.attributes.AvailableWavelengths> availableDegreeWLs = new HashMap<>();
+ availableDegreeWLs.putAll(degreeAttributesBuilder.getAvailableWavelengths());
+ AvailableWavelengths availableWaveLength =
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes
+ .AvailableWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthNumber)).build();
+ availableDegreeWLs.put(availableWaveLength.key(), availableWaveLength);
degreeAttributesBuilder.setAvailableWavelengths(availableDegreeWLs);
node1Builder.setDegreeAttributes(degreeAttributesBuilder.build());
break;
} else {
srgAttributesBuilder = new SrgAttributesBuilder(srgAttributes);
}
- List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
- .AvailableWavelengths> availableSrgWLs = new ArrayList<>(srgAttributesBuilder
- .getAvailableWavelengths());
- availableSrgWLs.add(new AvailableWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthNumber))
- .build());
+ Map<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
+ .AvailableWavelengthsKey,
+ org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
+ .AvailableWavelengths> availableSrgWLs = new HashMap<>();
+ availableSrgWLs.putAll(srgAttributesBuilder.getAvailableWavelengths());
+ org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130
+ .srg.node.attributes.AvailableWavelengths aval =
+ new AvailableWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthNumber))
+ .build();
+ availableSrgWLs.put(aval.key(),aval);
srgAttributesBuilder.setAvailableWavelengths(availableSrgWLs);
node1Builder.setSrgAttributes(srgAttributesBuilder.build());
break;
tp1Builder = new TerminationPoint1Builder();
}
+ UsedWavelengths usedWaveLength = new UsedWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthIndex))
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build();
switch (tp2.getTpType()) {
//switch (((org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.TerminationPoint1) tp)
// .getTpType()) {
case DEGREETXTTP:
case DEGREETXRXTTP:
TxTtpAttributes txTtpAttributes = null;
- List<UsedWavelengths> usedDegreeTxTtpWls;
+ Map<UsedWavelengthsKey,UsedWavelengths> usedDegreeTxTtpWls;
if (tp1 != null) {
txTtpAttributes = tp1.getTxTtpAttributes();
}
TxTtpAttributesBuilder txTtpAttributesBuilder;
+ usedDegreeTxTtpWls = new HashMap<>();
if (txTtpAttributes == null) {
txTtpAttributesBuilder = new TxTtpAttributesBuilder();
- usedDegreeTxTtpWls = new ArrayList<>();
} else {
txTtpAttributesBuilder = new TxTtpAttributesBuilder(txTtpAttributes);
- usedDegreeTxTtpWls = new ArrayList<>(txTtpAttributesBuilder.getUsedWavelengths());
+ usedDegreeTxTtpWls.putAll(txTtpAttributesBuilder.getUsedWavelengths());
}
- usedDegreeTxTtpWls.add(new UsedWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthIndex))
- .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
+ usedDegreeTxTtpWls.put(usedWaveLength.key(),usedWaveLength);
txTtpAttributesBuilder.setUsedWavelengths(usedDegreeTxTtpWls);
tp1Builder.setTxTtpAttributes(txTtpAttributesBuilder.build());
break;
case DEGREERXTTP:
RxTtpAttributes rxTtpAttributes = null;
- List<UsedWavelengths> usedDegreeRxTtpWls;
+ Map<UsedWavelengthsKey,UsedWavelengths> usedDegreeRxTtpWls;
if (tp1 != null) {
rxTtpAttributes = tp1.getRxTtpAttributes();
}
RxTtpAttributesBuilder rxTtpAttributesBuilder;
+ usedDegreeRxTtpWls = new HashMap<>();
if (rxTtpAttributes == null) {
rxTtpAttributesBuilder = new RxTtpAttributesBuilder();
- usedDegreeRxTtpWls = new ArrayList<>();
} else {
rxTtpAttributesBuilder = new RxTtpAttributesBuilder(rxTtpAttributes);
- usedDegreeRxTtpWls = new ArrayList<>(rxTtpAttributesBuilder.getUsedWavelengths());
+ usedDegreeRxTtpWls.putAll(rxTtpAttributesBuilder.getUsedWavelengths());
}
- usedDegreeRxTtpWls.add(new UsedWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthIndex))
- .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
+ usedDegreeRxTtpWls.put(usedWaveLength.key(),usedWaveLength);
rxTtpAttributesBuilder.setUsedWavelengths(usedDegreeRxTtpWls);
tp1Builder.setRxTtpAttributes(rxTtpAttributesBuilder.build());
break;
case DEGREERXCTP:
case DEGREETXRXCTP:
CtpAttributes ctpAttributes = null;
- List<UsedWavelengths> usedDegreeCtpWls;
+ Map<UsedWavelengthsKey,UsedWavelengths> usedDegreeCtpWls;
if (tp1 != null) {
ctpAttributes = tp1.getCtpAttributes();
}
CtpAttributesBuilder ctpAttributesBuilder;
+ usedDegreeCtpWls = new HashMap<>();
if (ctpAttributes == null) {
ctpAttributesBuilder = new CtpAttributesBuilder();
- usedDegreeCtpWls = new ArrayList<>();
} else {
ctpAttributesBuilder = new CtpAttributesBuilder(ctpAttributes);
- usedDegreeCtpWls = new ArrayList<>(ctpAttributesBuilder.getUsedWavelengths());
+ usedDegreeCtpWls.putAll(ctpAttributesBuilder.getUsedWavelengths());
}
- usedDegreeCtpWls.add(new UsedWavelengthsBuilder().setIndex(Uint32.valueOf(wavelengthIndex))
- .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
+ usedDegreeCtpWls.put(usedWaveLength.key(),usedWaveLength);
ctpAttributesBuilder.setUsedWavelengths(usedDegreeCtpWls);
tp1Builder.setCtpAttributes(ctpAttributesBuilder.build());
break;
case SRGRXCP:
case SRGTXRXCP:
CpAttributes cpAttributes = null;
- List<org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network
+ Map<org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network
+ .node.termination.point.cp.attributes.UsedWavelengthsKey,
+ org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network
.node.termination.point.cp.attributes.UsedWavelengths> usedDegreeCpWls;
if (tp1 != null) {
cpAttributes = tp1.getCpAttributes();
}
CpAttributesBuilder cpAttributesBuilder;
+ usedDegreeCpWls = new HashMap<>();
if (cpAttributes == null) {
cpAttributesBuilder = new CpAttributesBuilder();
- usedDegreeCpWls = new ArrayList<>();
} else {
cpAttributesBuilder = new CpAttributesBuilder(cpAttributes);
- usedDegreeCpWls = new ArrayList<>(cpAttributesBuilder.getUsedWavelengths());
+ usedDegreeCpWls.putAll(cpAttributesBuilder.getUsedWavelengths());
}
- usedDegreeCpWls.add(new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130
- .networks.network.node.termination.point.cp.attributes.UsedWavelengthsBuilder()
- .setIndex(Uint32.valueOf(wavelengthIndex))
- .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
+ org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks
+ .network.node.termination.point.cp.attributes.UsedWavelengths cpUsedWaveLength =
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130
+ .networks.network.node.termination.point.cp.attributes.UsedWavelengthsBuilder()
+ .setIndex(Uint32.valueOf(wavelengthIndex))
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build();
+ usedDegreeCpWls.put(cpUsedWaveLength.key(),cpUsedWaveLength);
cpAttributesBuilder.setUsedWavelengths(usedDegreeCpWls);
tp1Builder.setCpAttributes(cpAttributesBuilder.build());
break;
case SRGRXPP:
case SRGTXPP:
PpAttributes ppAttributes = null;
- List<UsedWavelength> usedDegreePpWls;
+ Map<UsedWavelengthKey, UsedWavelength> usedDegreePpWls;
if (tp1 != null) {
ppAttributes = tp1.getPpAttributes();
}
PpAttributesBuilder ppAttributesBuilder;
+ usedDegreePpWls = new HashMap<>();
if (ppAttributes == null) {
ppAttributesBuilder = new PpAttributesBuilder();
- usedDegreePpWls = new ArrayList<>();
} else {
ppAttributesBuilder = new PpAttributesBuilder(ppAttributes);
- usedDegreePpWls = new ArrayList<>(ppAttributesBuilder.getUsedWavelength());
+ usedDegreePpWls.putAll(ppAttributesBuilder.getUsedWavelength());
}
- usedDegreePpWls.add(new UsedWavelengthBuilder().setIndex(Uint32.valueOf(wavelengthIndex))
- .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build());
+ UsedWavelength usedDegreeWaveLength = new UsedWavelengthBuilder()
+ .setIndex(Uint32.valueOf(wavelengthIndex))
+ .setFrequency(centralTHz).setWidth(FrequencyGHz.getDefaultInstance("40")).build();
+ usedDegreePpWls.put(usedDegreeWaveLength.key(),usedDegreeWaveLength);
ppAttributesBuilder.setUsedWavelength(usedDegreePpWls);
tp1Builder.setPpAttributes(ppAttributesBuilder.build());
break;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev170206.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev161014.AdminStates;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.EthAttributes;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.Interface1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev161014.ethernet.container.EthernetBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev161014.EthernetCsmacd;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.OtuAttributes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.otu.container.OtuBuilder;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.setAutoNegotiation(EthAttributes.AutoNegotiation.Enabled)
.setDuplex(EthAttributes.Duplex.Full)
.setFec(EthAttributes.Fec.Off)
- .setSpeed(100000L)
- .setMtu(9000L);
+ .setSpeed(Uint32.valueOf(100000))
+ .setMtu(Uint32.valueOf(9000));
InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
logicalConnPoint + "-ETHERNET");
// Create Interface1 type object required for adding as augmentation
Interface1Builder ethIf1Builder = new Interface1Builder();
- ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+ ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
String key) {
- InterfaceBuilder interfaceBuilder = new InterfaceBuilder()
+ return new InterfaceBuilder()
.setDescription(" TBD ")
.setCircuitId(" TBD ")
.setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
.setType(type)
.setName(key)
.withKey(new InterfaceKey(key));
- return interfaceBuilder;
}
/**
* This methods creates an OTU interface on the given termination point.
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder otuIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1Builder();
- otuInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev161014.Interface1.class,
- otuIf1Builder.setOtu(otuIfBuilder.build()).build());
+ otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder oduIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev161014.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
// OCH interface specific data
- OchBuilder ocIfBuilder = new OchBuilder().setWavelengthNumber(waveNumber);
+ OchBuilder ocIfBuilder = new OchBuilder().setWavelengthNumber(Uint32.valueOf(waveNumber));
// Add supporting OMS interface
if (portMap.getSupportingOms() != null) {
org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1Builder
ochIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces
.rev161014.Interface1Builder();
- ochInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1.class,
- ochIf1Builder.setOch(ocIfBuilder.build()).build());
+ ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
List<String> interfacesCreated = new ArrayList<>();
// Post interface on the device
// OCH interface specific data
OchBuilder ocIfBuilder = new OchBuilder()
- .setWavelengthNumber(waveNumber)
+ .setWavelengthNumber(Uint32.valueOf(waveNumber))
.setModulationFormat(format)
.setRate(R100G.class)
.setTransmitPower(new PowerDBm(new BigDecimal("-5")));
// Create generic interface
InterfaceBuilder ochInterfaceBldr = createGenericInterfaceBuilder(portMap, OpticalChannel.class,
createOpenRoadmOchInterfaceName(logicalConnPoint, waveNumber));
- ochInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev161014.Interface1.class,
- ochIf1Builder.setOch(ocIfBuilder.build()).build());
+ ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
.Interface1Builder otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm
.optical.transport.interfaces.rev161014.Interface1Builder();
- otsInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev161014
- .Interface1.class,
- otsIf1Builder.setOts(otsIfBuilder.build()).build());
+ otsInterfaceBldr.addAugmentation(otsIf1Builder.setOts(otsIfBuilder.build()).build());
this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
this.portMapping.updateMapping(nodeId, mapping);
return otsInterfaceBldr.build().getName();
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container.org.openroadm.device.RoadmConnectionsKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.EthAttributes;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
logicalConnPoint + "-ETHERNET");
// Create Interface1 type object required for adding as augmentation
Interface1Builder ethIf1Builder = new Interface1Builder();
- ethInterfaceBldr.addAugmentation(Interface1.class, ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+ ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(nodeId, ethInterfaceBldr);
new org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1Builder()
.setMcTtp(mcTtpBuilder.build());
- mcInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.media.channel.interfaces.rev181019.Interface1.class,
- interface1Builder.build());
+ mcInterfaceBldr.addAugmentation(interface1Builder.build());
// Post interface on the device
openRoadmInterfaces.postInterface(nodeId, mcInterfaceBldr);
// 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(
- org.opendaylight.yang.gen.v1.http.org.openroadm.network.media.channel.interfaces.rev181019.Interface1.class,
- nmcCtpI1fBuilder.build());
+ 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);
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(
- org.opendaylight.yang.gen.v1.http.org.openroadm.optical.channel.interfaces.rev181019.Interface1.class,
- ochIf1Builder.setOch(ocIfBuilder.build()).build());
+ ochInterfaceBldr.addAugmentation(ochIf1Builder.setOch(ocIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(nodeId, ochInterfaceBldr);
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
- otuInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1.class,
- otuIf1Builder.setOtu(otuIfBuilder.build()).build());
+ otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(nodeId, otuInterfaceBldr);
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder otuIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1Builder();
- otuInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.otu.interfaces.rev181019.Interface1.class,
- otuIf1Builder.setOtu(otuIfBuilder.build()).build());
+ otuInterfaceBldr.addAugmentation(otuIf1Builder.setOtu(otuIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(anodeId, otuInterfaceBldr);
private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap, Class<? extends InterfaceType> type,
String key) {
- InterfaceBuilder interfaceBuilder = new InterfaceBuilder()
+ return new InterfaceBuilder()
.setDescription(" TBD ")
.setCircuitId(" TBD ")
.setSupportingCircuitPackName(portMap.getSupportingCircuitPackName())
.setType(type)
.setName(key)
.withKey(new InterfaceKey(key));
- return interfaceBuilder;
}
public String createOpenRoadmOmsInterface(String nodeId, Mapping mapping) throws OpenRoadmInterfaceException {
org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1Builder
otsIf1Builder = new org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces
.rev181019.Interface1Builder();
- otsInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.optical.transport.interfaces.rev181019.Interface1.class,
- otsIf1Builder.setOts(otsIfBuilder.build()).build());
+ otsInterfaceBldr.addAugmentation(otsIf1Builder.setOts(otsIfBuilder.build()).build());
this.openRoadmInterfaces.postInterface(nodeId, otsInterfaceBldr);
this.portMapping.updateMapping(nodeId, mapping);
return otsInterfaceBldr.build().getName();
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(nodeId, oduInterfaceBldr);
// TODO look at imports of different versions of class
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder oduIf1Builder =
new org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
openRoadmInterfaces.postInterface(anodeId, oduInterfaceBldr);
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.InterfaceKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev171215.AdminStates;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.Interface1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.ethernet.interfaces.rev181019.ethernet.container.EthernetBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.interfaces.rev170626.EthernetCsmacd;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.opu.OpuBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.parent.odu.allocation.ParentOduAllocationBuilder;
import org.opendaylight.yangtools.yang.common.Uint16;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// Ethernet interface specific data
EthernetBuilder ethIfBuilder = new EthernetBuilder()
- .setSpeed(1000L);
+ .setSpeed(Uint32.valueOf(1000));
InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(
portMap, EthernetCsmacd.class,
logicalConnPoint + "-ETHERNET1G");
// Create Interface1 type object required for adding as augmentation
Interface1Builder ethIf1Builder = new Interface1Builder();
- ethInterfaceBldr.addAugmentation(Interface1.class,
- ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+ ethInterfaceBldr.addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, ethInterfaceBldr);
// Post the equipment-state change on the device circuit-pack
private InterfaceBuilder createGenericInterfaceBuilder(Mapping portMap,
Class<? extends InterfaceType> type, String key) {
- InterfaceBuilder interfaceBuilder = new InterfaceBuilder()
+ return new InterfaceBuilder()
// .setDescription(" TBD ")
// .setCircuitId(" TBD ")
.setSupportingCircuitPackName(
.setAdministrativeState(AdminStates.InService)
// TODO get rid of unchecked cast warning
.setType(type).setName(key).withKey(new InterfaceKey(key));
- return interfaceBuilder;
}
public String createOpenRoadmEth10GInterface(String nodeId,
// Ethernet interface specific data
EthernetBuilder ethIfBuilder = new EthernetBuilder()
// .setAutoNegotiation(EthAttributes.AutoNegotiation.Disabled)
- .setSpeed(10000L);
+ .setSpeed(Uint32.valueOf(10000));
// Create Interface1 type object required for adding as augmentation
Interface1Builder ethIf1Builder = new Interface1Builder();
InterfaceBuilder ethInterfaceBldr = createGenericInterfaceBuilder(portMap, EthernetCsmacd.class,
- logicalConnPoint + "-ETHERNET10G").addAugmentation(Interface1.class,
- ethIf1Builder.setEthernet(ethIfBuilder.build()).build());
+ logicalConnPoint + "-ETHERNET10G").addAugmentation(ethIf1Builder.setEthernet(ethIfBuilder.build())
+ .build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, ethInterfaceBldr);
// Post the equipment-state change on the device circuit-pack
IntStream.range(tribSlotIndex, tribSlotIndex + 8)
.forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
- .setTribPortNumber(tribPortNumber)
+ .setTribPortNumber(Uint16.valueOf(tribPortNumber))
.setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
oduIf1Builder = new
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
tribSlots.add(Uint16.valueOf(tribSlot));
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
// set trib port numbers
- .setTribPortNumber(tribPortNumber)
+ .setTribPortNumber(Uint16.valueOf(tribPortNumber))
.setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
oduIf1Builder = new
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
.forEach(nbr -> tribSlots.add(Uint16.valueOf(nbr)));
ParentOduAllocationBuilder parentOduAllocationBuilder = new ParentOduAllocationBuilder()
// set trib port numbers
- .setTribPortNumber(tribPortNumber)
+ .setTribPortNumber(Uint16.valueOf(tribPortNumber))
.setTribSlots(tribSlots);
oduIfBuilder.setOduFunction(ODUCTP.class)
.setMonitoringMode(OduAttributes.MonitoringMode.Monitored)
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder
oduIf1Builder = new
org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1Builder();
- oduInterfaceBldr.addAugmentation(
- org.opendaylight.yang.gen.v1.http.org.openroadm.otn.odu.interfaces.rev181019.Interface1.class,
- oduIf1Builder.setOdu(oduIfBuilder.build()).build());
+ oduInterfaceBldr.addAugmentation(oduIf1Builder.setOdu(oduIfBuilder.build()).build());
// Post interface on the device
this.openRoadmInterfaces.postOTNInterface(nodeId, oduInterfaceBldr);
import com.google.common.util.concurrent.FluentFuture;
import java.math.BigDecimal;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.ExecutionException;
@Override
public ServicePathOutput setupServicePath(ServicePathInput input, ServicePathDirection direction) {
- List<Nodes> nodes = input.getNodes();
+ List<Nodes> nodes = new ArrayList<>();
+ if (input.getNodes() != null) {
+ nodes.addAll(input.getNodes());
+ }
// Register node for suppressing alarms
if (!alarmSuppressionNodeRegistration(input)) {
LOG.warn("Alarm suppresion node registration failed!!!!");
}
ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
- Set<NodeInterface> nodeInterfaces = Sets.newConcurrentHashSet();
+ Map<NodeInterfaceKey,NodeInterface> nodeInterfaces = new ConcurrentHashMap<>();
Set<String> nodesProvisioned = Sets.newConcurrentHashSet();
CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
ServiceListTopology topology = new ServiceListTopology();
.setOtuInterfaceId(createdOtuInterfaces)
.setOduInterfaceId(createdOduInterfaces)
.setOchInterfaceId(createdOchInterfaces);
- nodeInterfaces.add(nodeInterfaceBuilder.build());
+ NodeInterface nodeInterface = nodeInterfaceBuilder.build();
+ nodeInterfaces.put(nodeInterface.key(),nodeInterface);
}));
try {
forkJoinTask.get();
LOG.error("Alarm suppresion node removal failed!!!!");
}
ServicePathOutputBuilder setServBldr = new ServicePathOutputBuilder()
- .setNodeInterface(new ArrayList<>(nodeInterfaces))
+ .setNodeInterface(nodeInterfaces)
.setSuccess(success.get())
.setResult(String.join("\n", results));
return setServBldr.build();
@Override
public RendererRollbackOutput rendererRollback(RendererRollbackInput input) {
boolean success = true;
- List<FailedToRollback> failedToRollbackList = new ArrayList<>();
- for (NodeInterface nodeInterfaces : input.getNodeInterface()) {
+ Map<FailedToRollbackKey,FailedToRollback> failedToRollbackList = new HashMap<>();
+ for (NodeInterface nodeInterfaces : input.nonnullNodeInterface().values()) {
List<String> failedInterfaces = new ArrayList<>();
String nodeId = nodeInterfaces.getNodeId();
for (String connectionId : nodeInterfaces.getConnectionId()) {
failedInterfaces.add(interfaceId);
}
}
- failedToRollbackList.add(new FailedToRollbackBuilder().withKey(new FailedToRollbackKey(nodeId))
- .setNodeId(nodeId).setInterface(failedInterfaces).build());
+ FailedToRollback failedToRollack = new FailedToRollbackBuilder().withKey(new FailedToRollbackKey(nodeId))
+ .setNodeId(nodeId).setInterface(failedInterfaces).build();
+ failedToRollbackList.put(failedToRollack.key(),failedToRollack);
}
return new RendererRollbackOutputBuilder().setSuccess(success).setFailedToRollback(failedToRollbackList)
.build();
NodelistBuilder nodeListBuilder = new NodelistBuilder()
.withKey(new NodelistKey(input.getServiceName()))
.setServiceName(input.getServiceName());
- List<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service
+ Map<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service
+ .nodelist.nodelist.NodesKey,
+ org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102.service
.nodelist.nodelist.Nodes> nodeList =
- new ArrayList<>();
- for (Nodes node : input.getNodes()) {
- nodeList.add(
- new org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102
- .service.nodelist.nodelist.NodesBuilder()
- .setNodeId(node.getNodeId()).build());
+ new HashMap<>();
+ if (input.getNodes() != null) {
+ for (Nodes node : input.getNodes()) {
+ org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102
+ .service.nodelist.nodelist.Nodes nodes =
+ new org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102
+ .service.nodelist.nodelist.NodesBuilder().setNodeId(node.getNodeId()).build();
+ nodeList.put(nodes.key(),nodes);
+ }
}
nodeListBuilder.setNodes(nodeList);
InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102
.service.nodelist.Nodelist> nodeListIID =
- InstanceIdentifier.create(ServiceNodelist.class).child(
- org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression
- .rev171102.service.nodelist.Nodelist.class,
- new NodelistKey(input.getServiceName()));
+ InstanceIdentifier.create(ServiceNodelist.class)
+ .child(org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102
+ .service.nodelist.Nodelist.class, new NodelistKey(input.getServiceName()));
final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
writeTransaction.merge(LogicalDatastoreType.CONFIGURATION, nodeListIID, nodeListBuilder.build());
FluentFuture<? extends @NonNull CommitInfo> commit = writeTransaction.commit();
private boolean alarmSuppressionNodeRemoval(String serviceName) {
InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102
.service.nodelist.Nodelist> nodeListIID =
- InstanceIdentifier.create(ServiceNodelist.class).child(
- org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression
- .rev171102.service.nodelist.Nodelist.class,
- new NodelistKey(serviceName));
+ InstanceIdentifier.create(ServiceNodelist.class)
+ .child(org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.alarmsuppression.rev171102
+ .service.nodelist.Nodelist.class, new NodelistKey(serviceName));
final WriteTransaction writeTransaction = this.dataBroker.newWriteOnlyTransaction();
writeTransaction.delete(LogicalDatastoreType.CONFIGURATION, nodeListIID);
FluentFuture<? extends @NonNull CommitInfo> commit = writeTransaction.commit();
package org.opendaylight.transportpce.renderer.provisiondevice;
import java.util.ArrayList;
+import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
+import java.util.Map;
import java.util.Optional;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.CopyOnWriteArrayList;
results.add("Otn Service path was set up successfully for node :" + nodeInterface.getNodeId());
}
}
+ Map<NodeInterfaceKey,NodeInterface> nodeInterfacesMap = new HashMap<>();
+ for (NodeInterface nodeInterface : nodeInterfaces) {
+ if (nodeInterface != null) {
+ nodeInterfacesMap.put(nodeInterface.key(), nodeInterface);
+ }
+ }
OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
.setSuccess(success)
- .setNodeInterface(nodeInterfaces)
+ .setNodeInterface(nodeInterfacesMap)
.setResult(String.join("\n", results));
return otnServicePathOutputBuilder.build();
}
package org.opendaylight.transportpce.renderer.provisiondevice.otn;
import java.util.ArrayList;
+import java.util.Collection;
import java.util.List;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.CircuitPacks;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.pack.Ports;
public String validateClientPort(String circuitPackName, String portName, String capacity,
PortGroupRestriction portGroupRestriction) {
-
List<PortBandwidthSharing> portBandwidthSharingList = portGroupRestriction
- .getPortBandwidthSharing();
+
Collection<PortBandwidthSharing> portBandwidthSharingList = portGroupRestriction
+ .nonnullPortBandwidthSharing().values();
if (portGroupRestriction.getPortBandwidthSharing() != null) {
for (PortBandwidthSharing portBandwidthSharing : portBandwidthSharingList) {
- List<PortList> portLists = portBandwidthSharing.getPortList();
+ Collection<PortList> portLists = portBandwidthSharing.nonnullPortList().values();
for (PortList portList : portLists) {
if (portList.getCircuitPackName().equals(circuitPackName)
&& portList.getPortName().equals(portName)) {
}
private Integer getConfigID(PortBandwidthSharing portBandwidthSharing, String circuitPackName, String portName) {
- List<PossiblePortConfig> possiblePortConfigList = portBandwidthSharing.getPossiblePortConfig();
+ Collection<PossiblePortConfig> possiblePortConfigList = portBandwidthSharing
+ .nonnullPossiblePortConfig().values();
for (PossiblePortConfig possiblePortConfig: possiblePortConfigList
) {
- List<PortIfTypeConfig> portIfTypeConfigList = possiblePortConfig.getPortIfTypeConfig();
+ Collection<PortIfTypeConfig> portIfTypeConfigList = possiblePortConfig.nonnullPortIfTypeConfig().values();
for (PortIfTypeConfig portIfTypeConfig : portIfTypeConfigList) {
if (portIfTypeConfig.getCircuitPackName().equals(circuitPackName)
&& portIfTypeConfig.getPortName().equals(portName)) {
List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org
.openroadm.device.container.org.openroadm.device.odu.switching
.pools.non.blocking.list.PortList> networkPortList = new ArrayList<>();
- List<NonBlockingList> nonBlockingLists = oduSwitchingPools.getNonBlockingList();
+ Collection<NonBlockingList> nonBlockingLists = oduSwitchingPools.nonnullNonBlockingList().values();
for (NonBlockingList nonBlockingList: nonBlockingLists) {
for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device
.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList port:
- nonBlockingList.getPortList()) {
+ nonBlockingList.nonnullPortList().values()) {
if (port.getCircuitPackName().equals(circuitPackName) && port.getPortName().equals(portName)) {
org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device
.container.org.openroadm.device.odu.switching.pools.non.blocking.list
- .PortList networkPort = checkNetworkPorts(nonBlockingList.getPortList(), circuitPacks);
+ .PortList networkPort = checkNetworkPorts(nonBlockingList
+ .nonnullPortList().values(), circuitPacks);
if (networkPort != null) {
networkPortList.add(networkPort);
}
private org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device
.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList
- checkNetworkPorts(List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org
+ checkNetworkPorts(Collection<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org
.openroadm.device.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList> portList,
CircuitPacks circuitPacks) {
- List<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs
- .CircuitPacks> circuitPackList = circuitPacks.getCircuitPacks();
+ Collection<org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs
+ .CircuitPacks> circuitPackList = circuitPacks.nonnullCircuitPacks().values();
for (org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.org.openroadm.device.container
.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList port: portList) {
.container.org.openroadm.device.odu.switching.pools.non.blocking.list.PortList port,
org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.circuit.packs.CircuitPacks circuitPack) {
if (port.getCircuitPackName().equals(circuitPack.getCircuitPackName())) {
- for (Ports prt : circuitPack.getPorts()) {
+ for (Ports prt : circuitPack.nonnullPorts().values()) {
if (prt.getPortQual() != null
&& port.getPortName().equals(prt.getPortName())
&& "xpdr-network".equals(prt.getPortQual().getName())) {
*/
package org.opendaylight.transportpce.renderer.provisiondevice.servicepath;
-import java.util.ArrayList;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.node.types.rev181130.NodeIdType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.Topology;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.TopologyBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev190531.Hop.HopType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev190531.topology.AToZ;
import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev190531.topology.AToZBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev190531.topology.AToZKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev190531.topology.ZToA;
import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev190531.topology.ZToABuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.topology.rev190531.topology.ZToAKey;
public class ServiceListTopology {
- private List<AToZ> a2zTopologyList;
- private List<ZToA> z2aTopologyList;
- private TopologyBuilder serviceTopology;
-
- public ServiceListTopology() {
-
- this.a2zTopologyList = new ArrayList<>();
- this.z2aTopologyList = new ArrayList<>();
- this.serviceTopology = new TopologyBuilder();
-
- }
+ private Map<AToZKey,AToZ> a2zTopologyList = new HashMap<>();
+ private Map<ZToAKey,ZToA> z2aTopologyList = new HashMap<>();
+ private TopologyBuilder serviceTopology = new TopologyBuilder();
public void updateAtoZTopologyList(List<Ports> ports, String nodeId) {
a2zBldr.setResource(rsrcBldr.build());
//Add port resource to the list
- this.a2zTopologyList.add(a2zBldr.build());
+ AToZ a2z = a2zBldr.build();
+ this.a2zTopologyList.put(a2z.key(),a2z);
}
z2aBldr.setResource(rsrcBldr.build());
//Add port resource to the list
- this.z2aTopologyList.add(z2aBldr.build());
+ ZToA z2a = z2aBldr.build();
+ this.z2aTopologyList.put(z2a.key(),z2a);
}
package org.opendaylight.transportpce.renderer.provisiondevice.tasks;
import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import org.opendaylight.transportpce.renderer.provisiondevice.DeviceRendererService;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.RendererRollbackInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.RendererRollbackInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.RendererRollbackOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.renderer.rollback.output.FailedToRollback;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterface;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterfaceKey;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private static final Logger LOG = LoggerFactory.getLogger(DeviceRenderingRollbackTask.class);
private final boolean isRollbackNecessary;
private final DeviceRendererService rendererService;
- private final List<NodeInterface> renderedInterfaces;
+ private final Map<NodeInterfaceKey,NodeInterface> renderedInterfaces;
public DeviceRenderingRollbackTask(String id, boolean isRollbackNecessary, List<NodeInterface> renderedInterfaces,
DeviceRendererService rendererService) {
super(id);
this.isRollbackNecessary = isRollbackNecessary;
this.rendererService = rendererService;
- this.renderedInterfaces = renderedInterfaces;
+ this.renderedInterfaces = new HashMap<>();
+ if (renderedInterfaces != null) {
+ for (NodeInterface nodeInterface : renderedInterfaces) {
+ if (nodeInterface != null) {
+ this.renderedInterfaces.put(nodeInterface.key(), nodeInterface);
+ }
+ }
+ }
}
@Override
RendererRollbackOutput rollbackOutput = this.rendererService.rendererRollback(rollbackInput);
if (! rollbackOutput.isSuccess()) {
LOG.warn("Device rendering rollback of {} was not successful! Failed rollback on {}.", this.getId(),
- createErrorMessage(rollbackOutput.getFailedToRollback()));
+ createErrorMessage(rollbackOutput.nonnullFailedToRollback().values()));
} else {
LOG.info("Device rollback of {} successful.", this.getId());
}
return null;
}
- private String createErrorMessage(List<FailedToRollback> failedRollbacks) {
+ private String createErrorMessage(Collection<FailedToRollback> failedRollbacks) {
List<String> failedRollbackNodes = new ArrayList<>();
failedRollbacks.forEach(failedRollback -> {
String nodeId = failedRollback.getNodeId();
*/
package org.opendaylight.transportpce.renderer.provisiondevice.tasks;
+import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.Callable;
import org.opendaylight.transportpce.renderer.ServicePathInputData;
}
List<Nodes> olmList = this.servicePathInputData.getNodeLists().getOlmList();
LOG.info("Device rendering finished successfully.");
- return DeviceRenderingResult.ok(olmList, output.getNodeInterface());
+ return DeviceRenderingResult.ok(olmList, new ArrayList<>(output.nonnullNodeInterface().values()));
}
}
package org.opendaylight.transportpce.renderer.provisiondevice.tasks;
+import java.util.ArrayList;
import java.util.concurrent.Callable;
import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRendererService;
import org.opendaylight.transportpce.renderer.provisiondevice.OtnDeviceRenderingResult;
OtnServicePathOutput output = this.otnDeviceRenderer.setupOtnServicePath(this.otnServicePathInput);
if (Boolean.TRUE.equals(output.isSuccess())) {
LOG.info("Device rendering finished successfully.");
- return OtnDeviceRenderingResult.ok(output.getNodeInterface());
+ return OtnDeviceRenderingResult.ok(new ArrayList<>(output.nonnullNodeInterface().values()));
} else { //false or null case
LOG.warn("Device rendering not successfully finished.");
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Before;
import org.opendaylight.transportpce.test.AbstractTest;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev181130.FrequencyGHz;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.optical.channel.types.rev181130.FrequencyTHz;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengths;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.used.wavelengths.UsedWavelengths;
import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.used.wavelengths.UsedWavelengthsBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.used.wavelengths.UsedWavelengthsKey;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.TerminationPoint1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.termination.point.XpdrClientAttributesBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.termination.point.XpdrNetworkAttributesBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.termination.point.XpdrPortAttributesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.termination.point.pp.attributes.UsedWavelength;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks.network.node.termination.point.pp.attributes.UsedWavelengthBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmNodeType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmTpType;
@Ignore
@RunWith(Parameterized.class)
public class NetworkModelWaveLengthServiceFreeTest extends AbstractTest {
- private static final Long WAVE_LENGTH = 20L;
+ private static final Uint32 UI32_WAVE_LENGTH = Uint32.valueOf(20);
+ private static final long WAVE_LENGTH = 20L;
private NetworkModelWavelengthService networkModelWavelengthService;
private DeviceTransactionManager deviceTransactionManager;
private TerminationPoint1 terminationPoint1;
FrequencyGHz frequencyGHz = new FrequencyGHz(new BigDecimal(fixedFlex.getWavelength()));
FrequencyTHz frequencyTHz = new FrequencyTHz(new BigDecimal(fixedFlex.getCenterFrequency()));
+ UsedWavelength usedWaveLength = (new UsedWavelengthBuilder()).setIndex(UI32_WAVE_LENGTH).build();
+ UsedWavelengths usedWaveLengthDegree = (new UsedWavelengthsBuilder()).setIndex(UI32_WAVE_LENGTH).build();
+ Map<UsedWavelengthsKey, UsedWavelengths> usedWaveLengthDegreeMap =
+ Map.of(usedWaveLengthDegree.key(),usedWaveLengthDegree);
+ org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130
+ .networks.network.node.termination.point.cp.attributes.UsedWavelengths usedWaveLentgthCp =
+ (new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks
+ .network.node.termination.point.cp.attributes.UsedWavelengthsBuilder())
+ .setIndex(UI32_WAVE_LENGTH)
+ .build();
TerminationPoint1Builder terminationPoint1Builder = new TerminationPoint1Builder()
.setCtpAttributes((new CtpAttributesBuilder())
.setUsedWavelengths(
- Collections.singletonList((new UsedWavelengthsBuilder()).setIndex(WAVE_LENGTH).build()))
+ usedWaveLengthDegreeMap)
.build())
.setCpAttributes((new CpAttributesBuilder())
.setUsedWavelengths(
- Collections.singletonList(
- (new org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.networks
- .network.node.termination.point.cp.attributes.UsedWavelengthsBuilder())
- .setIndex(WAVE_LENGTH)
- .build()))
+ Map.of(usedWaveLentgthCp.key(),
+ usedWaveLentgthCp))
.build())
.setTxTtpAttributes((new TxTtpAttributesBuilder())
.setUsedWavelengths(
- Collections.singletonList((new UsedWavelengthsBuilder()).setIndex(WAVE_LENGTH).build()))
+ usedWaveLengthDegreeMap)
.build())
.setRxTtpAttributes((new RxTtpAttributesBuilder())
.setUsedWavelengths(
- Collections.singletonList((new UsedWavelengthsBuilder()).setIndex(WAVE_LENGTH).build()))
+ usedWaveLengthDegreeMap)
.build())
.setPpAttributes((new PpAttributesBuilder())
- .setUsedWavelength(
- Collections.singletonList((new UsedWavelengthBuilder()).setIndex(WAVE_LENGTH).build()))
+ .setUsedWavelength(Map.of(usedWaveLength.key(),usedWaveLength))
.build())
.setXpdrClientAttributes((new XpdrClientAttributesBuilder())
.setWavelength((new WavelengthBuilder())
.build());
Node1Builder node1Builder = new Node1Builder()
- .setDegreeAttributes((new DegreeAttributesBuilder()).setAvailableWavelengths(new ArrayList<>()).build())
- .setSrgAttributes((new SrgAttributesBuilder()).setAvailableWavelengths(new ArrayList<>()).build());
+ .setDegreeAttributes((new DegreeAttributesBuilder()).setAvailableWavelengths(Map.of()).build())
+ .setSrgAttributes((new SrgAttributesBuilder()).setAvailableWavelengths(Map.of()).build());
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.TerminationPoint1Builder
terminationPoint2Builder =
node2Builder.setNodeType(OpenroadmNodeType.SRG);
node1Builder
.setDegreeAttributes((new DegreeAttributesBuilder())
- .setAvailableWavelengths(new ArrayList<>())
+ .setAvailableWavelengths(Map.of())
.build())
.setSrgAttributes(null);
terminationPoint2Builder.setTpType(OpenroadmTpType.DEGREETXTTP);
Assert.assertNotNull(updatedTerminationPoint1.getXpdrPortAttributes().getWavelength());
break;
}
+ List<AvailableWavelengths> availableWavelengths = new ArrayList<>(updatedNode1
+ .getDegreeAttributes().nonnullAvailableWavelengths().values());
+ List<org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes.AvailableWavelengths>
+ availableWavelengths4srg =
+ new ArrayList<>(updatedNode1.getSrgAttributes().getAvailableWavelengths().values());
switch (updatedNode2.getNodeType()) {
//switch (((org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.Node1) updatedNode1)
// .getNodeType()) {
case DEGREE:
- Assert.assertEquals(1, updatedNode1.getDegreeAttributes().getAvailableWavelengths().size());
- Assert.assertEquals(Uint32.valueOf(WAVE_LENGTH),
- updatedNode1.getDegreeAttributes().getAvailableWavelengths().get(0).getIndex());
- Assert.assertTrue(updatedNode1.getSrgAttributes().getAvailableWavelengths().isEmpty());
+ Assert.assertEquals(1, availableWavelengths.size());
+ Assert.assertEquals(UI32_WAVE_LENGTH,
+ availableWavelengths.get(0).getIndex());
+ Assert.assertTrue(availableWavelengths4srg.isEmpty());
break;
case SRG:
- Assert.assertEquals(1, updatedNode1.getSrgAttributes().getAvailableWavelengths().size());
- Assert.assertEquals(Uint32.valueOf(WAVE_LENGTH),
- updatedNode1.getSrgAttributes().getAvailableWavelengths().get(0).getIndex());
- Assert.assertTrue(updatedNode1.getDegreeAttributes().getAvailableWavelengths().isEmpty());
+ Assert.assertEquals(1, availableWavelengths4srg.size());
+ Assert.assertEquals(UI32_WAVE_LENGTH,
+ availableWavelengths4srg.get(0).getIndex());
+ Assert.assertTrue(availableWavelengths.isEmpty());
break;
default:
- Assert.assertTrue(updatedNode1.getDegreeAttributes().getAvailableWavelengths().isEmpty());
- Assert.assertTrue(updatedNode1.getSrgAttributes().getAvailableWavelengths().isEmpty());
+ Assert.assertTrue(availableWavelengths.isEmpty());
+ Assert.assertTrue(availableWavelengths4srg.isEmpty());
break;
}
}
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
-import java.util.Collections;
import java.util.List;
+import java.util.Map;
import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Before;
import org.opendaylight.transportpce.renderer.utils.ServiceDeleteDataUtils;
import org.opendaylight.transportpce.renderer.utils.WaveLengthServiceUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengths;
import org.opendaylight.yang.gen.v1.http.org.openroadm.degree.rev181130.degree.node.attributes.AvailableWavelengthsBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev181130.Node1Builder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmNodeType;
import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev181130.OpenroadmTpType;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.PathDescription;
+import org.opendaylight.yangtools.yang.common.Uint32;
@Ignore
@RunWith(Parameterized.class)
ServiceDeleteDataUtils.createTransactionPathDescription(StringConstants.TTP_TOKEN);
TerminationPoint1Builder terminationPoint1Builder = new TerminationPoint1Builder()
- .setCtpAttributes((new CtpAttributesBuilder()).setUsedWavelengths(new ArrayList<>()).build())
- .setCpAttributes((new CpAttributesBuilder()).setUsedWavelengths(new ArrayList<>()).build())
- .setTxTtpAttributes((new TxTtpAttributesBuilder()).setUsedWavelengths(new ArrayList<>()).build())
- .setRxTtpAttributes((new RxTtpAttributesBuilder()).setUsedWavelengths(new ArrayList<>()).build())
- .setPpAttributes((new PpAttributesBuilder()).setUsedWavelength(new ArrayList<>()).build())
+ .setCtpAttributes((new CtpAttributesBuilder()).setUsedWavelengths(Map.of()).build())
+ .setCpAttributes((new CpAttributesBuilder()).setUsedWavelengths(Map.of()).build())
+ .setTxTtpAttributes((new TxTtpAttributesBuilder()).setUsedWavelengths(Map.of()).build())
+ .setRxTtpAttributes((new RxTtpAttributesBuilder()).setUsedWavelengths(Map.of()).build())
+ .setPpAttributes((new PpAttributesBuilder()).setUsedWavelength(Map.of()).build())
.setXpdrClientAttributes((new XpdrClientAttributesBuilder()).build())
.setXpdrNetworkAttributes((new XpdrNetworkAttributesBuilder()).build())
.setXpdrPortAttributes((new XpdrPortAttributesBuilder()).build());
+ AvailableWavelengths aval = new AvailableWavelengthsBuilder().setIndex(Uint32.valueOf(20)).build();
+ org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes.AvailableWavelengths avalSrg =
+ new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
+ .AvailableWavelengthsBuilder().setIndex(Uint32.valueOf(20)).build();
Node1Builder node1Builder = new Node1Builder()
.setDegreeAttributes((new DegreeAttributesBuilder())
.setAvailableWavelengths(
- Collections.singletonList(new AvailableWavelengthsBuilder().setIndex(20L).build()))
+ Map.of(aval.key(),aval))
.build())
.setSrgAttributes((new SrgAttributesBuilder())
.setAvailableWavelengths(
- Collections.singletonList(
- new org.opendaylight.yang.gen.v1.http.org.openroadm.srg.rev181130.srg.node.attributes
- .AvailableWavelengthsBuilder().setIndex(20L).build()))
+ Map.of(avalSrg.key(),avalSrg))
.build());
org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev181130.TerminationPoint1Builder
package org.opendaylight.transportpce.renderer.provisiondevice;
import java.util.ArrayList;
+import java.util.concurrent.ExecutionException;
import org.junit.Assert;
import org.junit.Test;
import org.mockito.Mockito;
import org.opendaylight.mdsal.binding.api.MountPoint;
import org.opendaylight.mdsal.binding.api.MountPointService;
+import org.opendaylight.mdsal.binding.api.WriteTransaction;
+import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.crossconnect.CrossConnectImpl;
import org.opendaylight.transportpce.renderer.utils.CreateOtsOmsDataUtils;
import org.opendaylight.transportpce.renderer.utils.MountPointUtils;
import org.opendaylight.transportpce.test.AbstractTest;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.Network;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.Nodes;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.NodesBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.NodesKey;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.NodeInfo;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev200827.network.nodes.NodeInfoBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.CreateOtsOmsInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.CreateOtsOmsOutput;
+import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
public class DeviceRendererServiceImplCreateOtsOmsTest extends AbstractTest {
}
@Test
- public void testCreateOtsOmsWhenDeviceIsMountedWithMapping() throws OpenRoadmInterfaceException {
+ public void testCreateOtsOmsWhenDeviceIsMountedWithMapping()
+ throws OpenRoadmInterfaceException, InterruptedException, ExecutionException {
+ InstanceIdentifier<NodeInfo> nodeInfoIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
+ new NodesKey("node 1")).child(NodeInfo.class).build();
+ InstanceIdentifier<Nodes> nodeIID = InstanceIdentifier.builder(Network.class).child(Nodes.class,
+ new NodesKey("node 1")).build();
+ final NodeInfo nodeInfo = new NodeInfoBuilder().setOpenroadmVersion(NodeInfo.OpenroadmVersion._221).build();
+ Nodes nodes = new NodesBuilder().setNodeId("node 1").setNodeInfo(nodeInfo).build();
+ WriteTransaction wr = getDataBroker().newWriteOnlyTransaction();
+ wr.merge(LogicalDatastoreType.CONFIGURATION, nodeIID, nodes);
+ wr.merge(LogicalDatastoreType.CONFIGURATION, nodeInfoIID, nodeInfo);
+ wr.commit().get();
setMountPoint(MountPointUtils.getMountPoint(new ArrayList<>(), getDataBroker()));
CreateOtsOmsInput input = CreateOtsOmsDataUtils.buildCreateOtsOms();
writePortMapping(input);
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
+import java.util.HashMap;
import java.util.List;
+import java.util.Map;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.RendererRollbackInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.RendererRollbackInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.ServicePathInput;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.Nodes;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.NodesBuilder;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.olm.renderer.input.NodesKey;
+import org.opendaylight.yangtools.yang.common.Uint32;
public final class ServiceDataUtils {
public static ServicePathInput buildServicePathInputs(List<Nodes> nodes) {
ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder();
servicePathInputBuilder.setNodes(nodes);
- servicePathInputBuilder.setServiceName("Service 1").setWaveNumber(20L);
+ servicePathInputBuilder.setServiceName("Service 1").setWaveNumber(Uint32.valueOf(20));
return servicePathInputBuilder.build();
}
List<Nodes> nodes = new ArrayList<>();
nodes.add(ServiceDataUtils.createNode("node1", "src", "dst"));
servicePathInputBuilder.setNodes(nodes);
- servicePathInputBuilder.setServiceName("Service 1").setWaveNumber(20L);
+ servicePathInputBuilder.setServiceName("Service 1").setWaveNumber(Uint32.valueOf(20));
return servicePathInputBuilder.build();
}
public static RendererRollbackInput buildRendererRollbackInput() {
RendererRollbackInputBuilder rendererRollbackInputBuilder = new RendererRollbackInputBuilder();
- rendererRollbackInputBuilder.setNodeInterface(new ArrayList<>());
+ rendererRollbackInputBuilder.setNodeInterface(Map.of());
return rendererRollbackInputBuilder.build();
}
}*/
private static PathDescription createPathDescriptionInvalidResource() {
- List<AToZ> atoZList = new ArrayList<AToZ>();
+ Map<AToZKey,AToZ> atoZMap = new HashMap<>();
org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource
.resource.resource.NodeBuilder nodesBuilder = new NodeBuilder();
org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource
.setResource(node1).build()).build();
AToZ atoZ2 = new AToZBuilder().setId("1").withKey(new AToZKey("1")).setResource(new ResourceBuilder()
.setResource(node2).build()).build();
- atoZList.add(atoZ);
- atoZList.add(atoZ2);
+ atoZMap.put(atoZ.key(),atoZ);
+ atoZMap.put(atoZ2.key(),atoZ2);
AToZDirection atozDirection = new AToZDirectionBuilder()
- .setRate(20L)
- .setAToZWavelengthNumber(20L)
- .setAToZ(atoZList)
+ .setRate(Uint32.valueOf(20))
+ .setAToZWavelengthNumber(Uint32.valueOf(32))
+ .setAToZ(atoZMap)
.build();
- List<ZToA> ztoAList = new ArrayList<ZToA>();
+ Map<ZToAKey,ZToA> ztoAMap = new HashMap<>();
ZToA ztoA = new ZToABuilder().setId("1").withKey(new ZToAKey("1")).setResource(new ResourceBuilder()
.setResource(node1).build()).build();
ZToA ztoA2 = new ZToABuilder().setId("1").withKey(new ZToAKey("1")).setResource(new ResourceBuilder()
.setResource(node2).build()).build();
- ztoAList.add(ztoA);
- ztoAList.add(ztoA2);
+ ztoAMap.put(ztoA.key(),ztoA);
+ ztoAMap.put(ztoA2.key(),ztoA2);
ZToADirection ztoaDirection = new ZToADirectionBuilder()
- .setRate(20L)
- .setZToAWavelengthNumber(20L)
- .setZToA(ztoAList)
+ .setRate(Uint32.valueOf(20))
+ .setZToAWavelengthNumber(Uint32.valueOf(20))
+ .setZToA(ztoAMap)
.build();
PathDescriptionBuilder builder = new PathDescriptionBuilder()
.setAToZDirection(atozDirection)
}
public static PathDescription createPathDescriptionTerminationPointResource(String tpId) {
- List<AToZ> atoZList = new ArrayList<AToZ>();
+ Map<AToZKey,AToZ> atoZMap = new HashMap<>();
TerminationPointBuilder terminationPointBuilder = new TerminationPointBuilder();
List<String> nodeIds = Arrays.asList("XPONDER-1-2", "XPONDER-2-3");
Integer atozId = 1;
.withKey(new AToZKey(atozId.toString())).setResource(new ResourceBuilder()
.setResource(terminationPoint).build()).build();
atozId++;
- atoZList.add(atoZ);
+ atoZMap.put(atoZ.key(),atoZ);
}
}
AToZDirection atozDirection = new AToZDirectionBuilder()
- .setRate(20L)
- .setAToZWavelengthNumber(20L)
- .setAToZ(atoZList)
+ .setRate(Uint32.valueOf(20))
+ .setAToZWavelengthNumber(Uint32.valueOf(20))
+ .setAToZ(atoZMap)
.build();
Collections.reverse(nodeIds);
- List<ZToA> ztoAList = new ArrayList<ZToA>();
+ Map<ZToAKey,ZToA> ztoAMap = new HashMap<>();
Integer ztoaId = 1;
for (String nodeId : nodeIds) {
for (String otherNodeId : nodeIds) {
.withKey(new ZToAKey(ztoaId.toString())).setResource(new ResourceBuilder()
.setResource(terminationPoint).build()).build();
ztoaId++;
- ztoAList.add(ztoA);
+ ztoAMap.put(ztoA.key(),ztoA);
}
}
ZToADirection ztoaDirection = new ZToADirectionBuilder()
- .setRate(20L)
- .setZToAWavelengthNumber(20L)
- .setZToA(ztoAList)
+ .setRate(Uint32.valueOf(20))
+ .setZToAWavelengthNumber(Uint32.valueOf(20))
+ .setZToA(ztoAMap)
.build();
PathDescriptionBuilder builder = new PathDescriptionBuilder()
.setAToZDirection(atozDirection)
}
private static PathDescription createPathDescriptionLinkResource() {
- List<AToZ> atoZList = new ArrayList<AToZ>();
-// org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.pce.resource
-// .resource.resource.NodeBuilder nodesBuilder = new NodeBuilder();
+ Map<AToZKey,AToZ> atoZMap = new HashMap<>();
Link link1 = new LinkBuilder().setLinkId("link 1").build();
Link link2 = new LinkBuilder().setLinkId("link 2").build();
AToZ atoZ = new AToZBuilder().setId("1").withKey(new AToZKey("1")).setResource(new ResourceBuilder()
.setResource(link1).build()).build();
AToZ atoZ2 = new AToZBuilder().setId("1").withKey(new AToZKey("1")).setResource(new ResourceBuilder()
.setResource(link2).build()).build();
- atoZList.add(atoZ);
- atoZList.add(atoZ2);
+ atoZMap.put(atoZ.key(),atoZ);
+ atoZMap.put(atoZ2.key(),atoZ2);
AToZDirection atozDirection = new AToZDirectionBuilder()
- .setRate(20L)
- .setAToZWavelengthNumber(20L)
- .setAToZ(atoZList)
+ .setRate(Uint32.valueOf(20))
+ .setAToZWavelengthNumber(Uint32.valueOf(20))
+ .setAToZ(atoZMap)
.build();
- List<ZToA> ztoAList = new ArrayList<ZToA>();
+ Map<ZToAKey,ZToA> ztoAMap = new HashMap<>();
ZToA ztoA = new ZToABuilder().setId("1").withKey(new ZToAKey("1")).setResource(new ResourceBuilder()
.setResource(link1).build()).build();
ZToA ztoA2 = new ZToABuilder().setId("1").withKey(new ZToAKey("1")).setResource(new ResourceBuilder()
.setResource(link2).build()).build();
- ztoAList.add(ztoA);
- ztoAList.add(ztoA2);
+ ztoAMap.put(ztoA.key(),ztoA);
+ ztoAMap.put(ztoA2.key(),ztoA2);
ZToADirection ztoaDirection = new ZToADirectionBuilder()
- .setRate(20L)
- .setZToAWavelengthNumber(20L)
- .setZToA(ztoAList)
+ .setRate(Uint32.valueOf(20))
+ .setZToAWavelengthNumber(Uint32.valueOf(20))
+ .setZToA(ztoAMap)
.build();
PathDescriptionBuilder builder = new PathDescriptionBuilder()
.setAToZDirection(atozDirection)
public static ServiceAEndBuilder getServiceAEndBuild(String tpId) {
return new ServiceAEndBuilder()
- .setClli("clli").setServiceFormat(ServiceFormat.OC).setServiceRate((long) 1).setNodeId("XPONDER-1-2-"
+ .setClli("clli").setServiceFormat(ServiceFormat.OC)
+ .setServiceRate(Uint32.valueOf(1)).setNodeId("XPONDER-1-2-"
+ tpId)
.setTxDirection(
new TxDirectionBuilder()
.setPortRack("port rack").setPortShelf("port shelf").setPortSlot("port slot")
.setPortSubSlot("port subslot").setPortType("port type").build())
.build())
- .setServiceRate(Long.valueOf(100))
+ .setServiceRate(Uint32.valueOf(100))
.setServiceFormat(ServiceFormat.Ethernet);
}
public static ServiceZEndBuilder getServiceZEndBuild(String tpId) {
return new ServiceZEndBuilder()
- .setClli("clli").setServiceFormat(ServiceFormat.OC).setServiceRate((long) 1).setNodeId("XPONDER-2-3-"
+ .setClli("clli").setServiceFormat(ServiceFormat.OC)
+ .setServiceRate(Uint32.valueOf(1)).setNodeId("XPONDER-2-3-"
+ tpId)
.setTxDirection(
new TxDirectionBuilder()
package org.opendaylight.transportpce.renderer.utils;
-import java.util.ArrayList;
-import java.util.List;
+import java.util.HashMap;
+import java.util.Map;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.service.port.PortBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.format.rev190531.ServiceFormat;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev200629.path.description.AToZDirection;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.PathDescriptionBuilder;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.ServiceAEndBuilder;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev200128.service.path.ServiceZEndBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
public final class ServiceDeleteDataUtils {
}
public static PathDescription createTransactionPathDescription(String tpId) {
- List<AToZ> atoZList = new ArrayList<AToZ>();
+ Map<AToZKey,AToZ> atoZMap = new HashMap<>();
TerminationPointBuilder terminationPointBuilder = new TerminationPointBuilder();
TerminationPoint terminationPoint = terminationPointBuilder.setTpNodeId("node2" + tpId)
.setTpId(tpId).build();
.setResource(terminationPoint).build()).build();
AToZ atoZ2 = new AToZBuilder().setId("2").withKey(new AToZKey("2")).setResource(new ResourceBuilder()
.setResource(terminationPoint2).build()).build();
- atoZList.add(atoZ);
- atoZList.add(atoZ2);
+ atoZMap.put(atoZ.key(),atoZ);
+ atoZMap.put(atoZ2.key(),atoZ2);
AToZDirection atozDirection = new AToZDirectionBuilder()
- .setRate(20L)
- .setAToZWavelengthNumber(20L)
- .setAToZ(atoZList)
+ .setRate(Uint32.valueOf(20))
+ .setAToZWavelengthNumber(Uint32.valueOf(20))
+ .setAToZ(atoZMap)
.setModulationFormat("OC")
.build();
- List<ZToA> ztoAList = new ArrayList<ZToA>();
+ Map<ZToAKey,ZToA> ztoAMap = new HashMap<>();
ZToA ztoA = new ZToABuilder().setId("1").withKey(new ZToAKey("1")).setResource(new ResourceBuilder()
.setResource(terminationPoint).build()).build();
ZToA ztoA2 = new ZToABuilder().setId("2").withKey(new ZToAKey("2")).setResource(new ResourceBuilder()
.setResource(terminationPoint).build()).build();
- ztoAList.add(ztoA);
- ztoAList.add(ztoA2);
+ ztoAMap.put(ztoA.key(),ztoA);
+ ztoAMap.put(ztoA2.key(),ztoA2);
ZToADirection ztoaDirection = new ZToADirectionBuilder()
- .setRate(20L)
- .setZToAWavelengthNumber(20L)
- .setZToA(ztoAList)
+ .setRate(Uint32.valueOf(20))
+ .setZToAWavelengthNumber(Uint32.valueOf(20))
+ .setZToA(ztoAMap)
.setModulationFormat("OC")
.build();
PathDescriptionBuilder pathDescriptionBuilder = new PathDescriptionBuilder();
public static ServiceAEndBuilder getServiceAEndBuild() {
return new ServiceAEndBuilder()
- .setClli("clli").setServiceFormat(ServiceFormat.OC).setServiceRate((long) 1).setNodeId("XPONDER-1-2")
+ .setClli("clli").setServiceFormat(ServiceFormat.OC)
+ .setServiceRate(Uint32.valueOf(1)).setNodeId("XPONDER-1-2")
.setTxDirection(
new TxDirectionBuilder()
.setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name")
public static ServiceZEndBuilder getServiceZEndBuild() {
return new ServiceZEndBuilder()
- .setClli("clli").setServiceFormat(ServiceFormat.OC).setServiceRate((long) 1).setNodeId("XPONDER-2-3")
+ .setClli("clli").setServiceFormat(ServiceFormat.OC)
+ .setServiceRate(Uint32.valueOf(1)).setNodeId("XPONDER-2-3")
.setTxDirection(
new TxDirectionBuilder()
.setPort(new PortBuilder().setPortDeviceName("device name").setPortName("port name")
return false;
}
DeviceTransaction deviceTx = deviceTxFuture.get().get();
- deviceTx.put(logicalDatastoreType, instanceIdentifier, object, true);
+ deviceTx.put(logicalDatastoreType, instanceIdentifier, object);
deviceTx.commit(Timeouts.DEVICE_WRITE_TIMEOUT, Timeouts.DEVICE_WRITE_TIMEOUT_UNIT).get();
return true;
}
Code Review / transportpce.git / commitdiff