import java.util.concurrent.ForkJoinTask;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
+import org.opendaylight.transportpce.common.StringConstants;
import org.opendaylight.transportpce.common.crossconnect.CrossConnect;
import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaceException;
import org.opendaylight.transportpce.common.openroadminterfaces.OpenRoadmInterfaces;
+import org.opendaylight.transportpce.common.service.ServiceTypes;
import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
import org.opendaylight.transportpce.renderer.openroadminterface.OpenRoadmInterfaceFactory;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathInput;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathOutput;
-import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.device.rev200128.OtnServicePathOutputBuilder;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.device.rev181019.interfaces.grp.Interface;
-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.NodeInterfaceBuilder;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.node.interfaces.NodeInterfaceKey;
-import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev200615.otn.renderer.input.Nodes;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev200129.OtnLinkType;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathInput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathOutput;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.OtnServicePathOutputBuilder;
+import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.common.types.rev200327.OpucnTribSlotDef;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.link.tp.LinkTp;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.link.tp.LinkTpBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterface;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterfaceBuilder;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.node.interfaces.NodeInterfaceKey;
+import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.otn.renderer.nodes.Nodes;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
boolean success = true;
List<NodeInterface> nodeInterfaces = new ArrayList<>();
List<String> results = new ArrayList<>();
- if (input.getServiceType() == null || input.getServiceRate() == null) {
+ if (input.getServiceFormat() == null || input.getServiceRate() == null) {
OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
.setSuccess(false)
.setResult("Error - service-type and service-rate must be presents");
return otnServicePathOutputBuilder.build();
}
- CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
- switch (input.getServiceType()) {
- case "Ethernet":
- if ("10G".equals(input.getServiceRate()) || "1G".equals(input.getServiceRate())) {
- try {
- LOG.info("Calling Node interfaces {} {} {} {} {} {} {}",
- input.getServiceRate(), input.getEthernetEncoding(),
- input.getServiceType(), input.getOperation(), input.getTribPortNumber(),
- input.getTribSlot(), input.getNodes());
- nodeInterfaces = createInterface(input);
+ CopyOnWriteArrayList<LinkTp> otnLinkTps = new CopyOnWriteArrayList<>();
+ String serviceType = ServiceTypes.getOtnServiceType(input.getServiceFormat(), input.getServiceRate());
+ switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_1GE:
+ case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_100GE_M:
+ try {
+ LOG.info("Calling Node interfaces {} {} {} {} {} {} {}",
+ input.getServiceRate(), input.getEthernetEncoding(),
+ input.getServiceFormat(), input.getOperation(), input.getTribPortNumber(),
+ input.getTribSlot(), input.getNodes());
+ if (input.getNodes() != null) {
+ createLowOrderInterfaces(input, nodeInterfaces, otnLinkTps);
LOG.info("Node interfaces created just fine ");
-
- List<String> nodesToUpdate = new ArrayList<>();
- if (!nodeInterfaces.isEmpty()) {
- for (NodeInterface nodeInterf : nodeInterfaces) {
- if (nodeInterf.getOduInterfaceId() != null) {
- List<String> interList = nodeInterf.getOduInterfaceId().stream()
- .filter(id -> id.contains("NETWORK")).collect(Collectors.toList());
- if (!interList.isEmpty()) {
- for (String inter : interList) {
- String tp = inter.split("-ODU")[0];
- String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0];
- nodesToUpdate.add(nodeTopo + "--" + tp);
- }
- }
- }
- }
- }
- updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
- input.getTribSlot(), false);
- } catch (OpenRoadmInterfaceException e) {
- LOG.warn("Set up service path failed", e);
- success = false;
}
- } else {
- LOG.warn("Unsupported service-rate for service-type Ethernet");
+ } catch (OpenRoadmInterfaceException e) {
+ LOG.warn("Set up service path failed", e);
+ success = false;
}
break;
- case "ODU":
- if ("100G".equals(input.getServiceRate())) {
- try {
- createODU4TtpInterface(input, nodeInterfaces, otnNodesProvisioned);
- updateOtnTopology(otnNodesProvisioned, null, null, null, null, false);
- } catch (OpenRoadmInterfaceException e) {
- LOG.warn("Set up service path failed", e);
- success = false;
- }
- } else {
- LOG.warn("Unsupported service-rate for service-type ODU");
+ case StringConstants.SERVICE_TYPE_ODU4:
+ try {
+ createODU4TtpInterface(input, nodeInterfaces, otnLinkTps);
+ } catch (OpenRoadmInterfaceException e) {
+ LOG.warn("Set up service path failed", e);
+ success = false;
+ }
+ break;
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ try {
+ createOduc4TtpInterface(input, nodeInterfaces, otnLinkTps);
+ } catch (OpenRoadmInterfaceException e) {
+ LOG.warn("Set up service path failed", e);
+ success = false;
}
break;
default:
- LOG.error("service-type {} not managed yet", input.getServiceType());
+ LOG.error("service-type {} not managed yet", serviceType);
break;
}
if (success) {
OtnServicePathOutputBuilder otnServicePathOutputBuilder = new OtnServicePathOutputBuilder()
.setSuccess(success)
.setNodeInterface(nodeInterfacesMap)
- .setResult(String.join("\n", results));
+ .setResult(String.join("\n", results))
+ .setLinkTp(otnLinkTps);
return otnServicePathOutputBuilder.build();
}
public OtnServicePathOutput deleteOtnServicePath(OtnServicePathInput input) {
- if (input == null) {
- LOG.error("Unable to delete otn service path. input = null");
- return new OtnServicePathOutputBuilder().setResult("Unable to delete otn service path. input = null")
+ if (input.getNodes() == null) {
+ LOG.error("Unable to delete otn service path. input nodes = null");
+ return new OtnServicePathOutputBuilder().setResult("Unable to delete otn service path. input nodes = null")
.setSuccess(false).build();
}
List<Nodes> nodes = input.getNodes();
AtomicBoolean success = new AtomicBoolean(true);
ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
- List<String> nodesTpToUpdate = new ArrayList<>();
- CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
+ CopyOnWriteArrayList<LinkTp> otnLinkTps = new CopyOnWriteArrayList<>();
ForkJoinPool forkJoinPool = new ForkJoinPool();
ForkJoinTask forkJoinTask = forkJoinPool.submit(() -> nodes.parallelStream().forEach(node -> {
List<String> interfacesToDelete = new LinkedList<>();
String nodeId = node.getNodeId();
LOG.info("Deleting service setup on node {}", nodeId);
String networkTp = node.getNetworkTp();
- if (networkTp == null || input.getServiceRate() == null || input.getServiceType() == null) {
- LOG.error("destination ({}) or service rate ({}) or service type ({}) is null.", networkTp,
- input.getServiceRate(), input.getServiceType());
+ if (networkTp == null || input.getServiceRate() == null || input.getServiceFormat() == null) {
+ LOG.error("destination ({}) or service-rate ({}) or service-format ({}) is null.", networkTp,
+ input.getServiceRate(), input.getServiceFormat());
return;
}
// if the node is currently mounted then proceed.
if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
String connectionNumber = "";
- switch (input.getServiceRate()) {
- case ("100G"):
- if ("ODU".equals(input.getServiceType())) {
+ switch (input.getServiceRate().intValue()) {
+ case 100:
+ if ("ODU".equals(input.getServiceFormat())) {
interfacesToDelete.add(networkTp + "-ODU4");
- otnNodesProvisioned.add(node);
if (node.getNetwork2Tp() != null) {
interfacesToDelete.add(node.getNetwork2Tp() + "-ODU4");
}
+ } else if ("Ethernet".equals(input.getServiceFormat())) {
+ connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU4");
}
break;
- case ("10G"):
+ case 400:
+ if ("ODU".equals(input.getServiceFormat())) {
+ interfacesToDelete.add(networkTp + "-ODUC4");
+ if (node.getNetwork2Tp() != null) {
+ interfacesToDelete.add(node.getNetwork2Tp() + "-ODUC4");
+ }
+ }
+ break;
+ case 10:
connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU2e");
break;
- case ("1G"):
+ case 1:
connectionNumber = getConnectionNumber(input.getServiceName(), node, networkTp, "ODU0");
break;
default:
for (String interf : intToDelete) {
if (!this.openRoadmInterfaceFactory.isUsedByOtnXc(nodeId, interf, connectionNumber,
this.deviceTransactionManager)) {
+
interfacesToDelete.add(interf);
- if (!getSupportedInterface(nodeId, interf).contains("ODU4")) {
- interfacesToDelete.add(getSupportedInterface(nodeId, interf));
+ String supportedInterface = this.openRoadmInterfaces.getSupportedInterface(nodeId, interf);
+ if (input.getServiceRate().intValue() == 100) {
+ if (!supportedInterface.contains("ODUC4")) {
+ interfacesToDelete.add(supportedInterface);
+ }
+ } else {
+ if (!supportedInterface.contains("ODU4")) {
+ interfacesToDelete.add(supportedInterface);
+ }
}
}
}
if (!interList.isEmpty()) {
for (String inter : interList) {
String tp = inter.split("-ODU")[0];
- String nodeTopo = nodeId + "-" + tp.split("-")[0];
- nodesTpToUpdate.add(nodeTopo + "--" + tp);
+ LinkTp otnLinkTp = new LinkTpBuilder()
+ .setNodeId(nodeId)
+ .setTpId(tp)
+ .build();
+ otnLinkTps.add(otnLinkTp);
}
}
}));
forkJoinTask.get();
} catch (InterruptedException | ExecutionException e) {
LOG.error("Error while deleting service paths!", e);
+ return new OtnServicePathOutputBuilder().setResult("Error while deleting service paths!")
+ .setSuccess(false).build();
}
forkJoinPool.shutdown();
- LOG.info("requesting otn-topology update...");
- if (!nodesTpToUpdate.isEmpty() && !"ODU".equals(input.getServiceType())) {
- updateOtnTopology(null, nodesTpToUpdate, input.getServiceRate(), input.getTribPortNumber(),
- input.getTribSlot(), true);
- } else if (!otnNodesProvisioned.isEmpty()) {
- updateOtnTopology(otnNodesProvisioned, null, null, null, null, true);
- }
-
- OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder();
- delServBldr.setSuccess(success.get());
+ OtnServicePathOutputBuilder delServBldr = new OtnServicePathOutputBuilder()
+ .setSuccess(success.get())
+ .setLinkTp(otnLinkTps);
if (results.isEmpty()) {
return delServBldr.setResult("Request processed").build();
} else {
}
}
- private String getSupportedInterface(String nodeId, String interf) {
- Optional<Interface> supInterfOpt;
- try {
- supInterfOpt = this.openRoadmInterfaces.getInterface(nodeId, interf);
- if (supInterfOpt.isPresent()) {
- return supInterfOpt.get().getSupportingInterface();
- } else {
- return null;
- }
- } catch (OpenRoadmInterfaceException e) {
- LOG.error("error getting Supported Interface of {} - {}", interf, nodeId, e);
- return null;
- }
- }
-
- private List<NodeInterface> createInterface(OtnServicePathInput input) throws OpenRoadmInterfaceException {
- List<NodeInterface> nodeInterfaces = new ArrayList<>();
- LOG.info("Calling Create Interface entry for OTN service path");
- if (input.getServiceRate() == null
- || !("1G".equals(input.getServiceRate()) || "10G".equals(input.getServiceRate()))) {
- LOG.error("Service rate {} not managed yet", input.getServiceRate());
- } else {
- createLowOrderInterfaces(input, nodeInterfaces);
- }
- return nodeInterfaces;
- }
-
private Optional<String> postCrossConnect(List<String> createdOduInterfaces, Nodes node)
throws OpenRoadmInterfaceException {
return this.crossConnect.postOtnCrossConnect(createdOduInterfaces, node);
}
- private void createLowOrderInterfaces(OtnServicePathInput input, List<NodeInterface> nodeInterfaces)
- throws OpenRoadmInterfaceException {
+ private void createLowOrderInterfaces(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
+ CopyOnWriteArrayList<LinkTp> linkTpList) throws OpenRoadmInterfaceException {
for (Nodes node : input.getNodes()) {
// check if the node is mounted or not?
List<String> createdEthInterfaces = new ArrayList<>();
List<String> createdOduInterfaces = new ArrayList<>();
- switch (input.getServiceRate()) {
- case ("1G"):
+ switch (input.getServiceRate().intValue()) {
+ case 1:
LOG.info("Input service is 1G");
if (node.getClientTp() != null) {
createdEthInterfaces.add(
createdOduInterfaces.add(
openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(), node.getNetworkTp(),
input.getServiceName(), PT_07, true, input.getTribPortNumber(), input.getTribSlot()));
+ LinkTp otnLinkTp = new LinkTpBuilder()
+ .setNodeId(node.getNodeId())
+ .setTpId(node.getNetworkTp())
+ .build();
+ linkTpList.add(otnLinkTp);
if (node.getNetwork2Tp() != null) {
createdOduInterfaces.add(
// supporting interface? payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu0Interface(node.getNodeId(),
node.getNetwork2Tp(), input.getServiceName(), PT_07, true, input.getTribPortNumber(),
input.getTribSlot()));
+ LinkTp otnLinkTp2 = new LinkTpBuilder()
+ .setNodeId(node.getNodeId())
+ .setTpId(node.getNetworkTp())
+ .build();
+ linkTpList.add(otnLinkTp2);
}
break;
- case ("10G"):
+ case 10:
LOG.info("Input service is 10G");
if (node.getClientTp() != null) {
createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth10GInterface(
// supporting interface? payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(), node.getNetworkTp(),
input.getServiceName(), PT_03, true, input.getTribPortNumber(), input.getTribSlot()));
+ LinkTp otnLinkTp3 = new LinkTpBuilder()
+ .setNodeId(node.getNodeId())
+ .setTpId(node.getNetworkTp())
+ .build();
+ linkTpList.add(otnLinkTp3);
if (node.getNetwork2Tp() != null) {
createdOduInterfaces.add(
// supporting interface? payload ?
openRoadmInterfaceFactory.createOpenRoadmOdu2eInterface(node.getNodeId(),
node.getNetwork2Tp(), input.getServiceName(), PT_03, true, input.getTribPortNumber(),
input.getTribSlot()));
+ LinkTp otnLinkTp4 = new LinkTpBuilder()
+ .setNodeId(node.getNodeId())
+ .setTpId(node.getNetworkTp())
+ .build();
+ linkTpList.add(otnLinkTp4);
+ }
+ break;
+ case 100:
+ LOG.info("Input service is 100G");
+ // Take the first and last value in the list of OpucnTribSlot (assuming SH would provide
+ // min and max value only, size two)
+ OpucnTribSlotDef minOpucnTs = OpucnTribSlotDef.getDefaultInstance(
+ input.getOpucnTribSlots().get(0).getValue());
+ OpucnTribSlotDef maxOpucnTs = OpucnTribSlotDef.getDefaultInstance(
+ input.getOpucnTribSlots().get(1).getValue());
+ if (node.getClientTp() != null) {
+ createdEthInterfaces.add(openRoadmInterfaceFactory.createOpenRoadmEth100GInterface(
+ node.getNodeId(), node.getClientTp()));
+ // OPUCn trib information is optional when creating ODU4 ethernet (client) interface
+ createdOduInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
+ node.getClientTp(), input.getServiceName(), PT_07, false, minOpucnTs,
+ maxOpucnTs));
+ }
+ // Here payload-type is optional and is not used for interface creation (especially for network)
+ createdOduInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
+ node.getNetworkTp(), input.getServiceName(), PT_07, true, minOpucnTs,
+ maxOpucnTs));
+ LinkTp otnLinkTp5 = new LinkTpBuilder()
+ .setNodeId(node.getNodeId())
+ .setTpId(node.getNetworkTp())
+ .build();
+ linkTpList.add(otnLinkTp5);
+ // Here payload-type is optional and is not used for service creation
+ // This is needed if there is an intermediate node
+ if (node.getNetwork2Tp() != null) {
+ createdOduInterfaces.add(
+ openRoadmInterfaceFactory.createOpenRoadmOtnOdu4LoInterface(node.getNodeId(),
+ node.getNetwork2Tp(), input.getServiceName(), PT_07, true, minOpucnTs,
+ maxOpucnTs));
+ LinkTp otnLinkTp6 = new LinkTpBuilder()
+ .setNodeId(node.getNodeId())
+ .setTpId(node.getNetworkTp())
+ .build();
+ linkTpList.add(otnLinkTp6);
}
break;
default:
}
}
- private void createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
- CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
-
+ private void createOduc4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
+ CopyOnWriteArrayList<LinkTp> linkTpList) throws OpenRoadmInterfaceException {
+ if (input.getNodes() == null) {
+ return;
+ }
+ LOG.info("Creation of ODUC4 TTP interface in OTN service path {}", input);
for (int i = 0; i < input.getNodes().size(); i++) {
Nodes node = input.getNodes().get(i);
- String supportingOtuInterface = node.getNetworkTp() + "-OTU";
- List<String> createdOdu4Interfaces = new ArrayList<>();
+ String supportingOtuInterface = node.getNetworkTp() + "-OTUC4";
+ List<String> createdOduc4Interfaces = new ArrayList<>();
// Adding SAPI/DAPI information to the
Nodes tgtNode = null;
if (i + 1 == input.getNodes().size()) {
} else {
tgtNode = input.getNodes().get(i + 1);
}
- createdOdu4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(node.getNodeId(),
+ createdOduc4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOduc4Interface(node.getNodeId(),
node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
+
NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
.withKey(new NodeInterfaceKey(node.getNodeId()))
.setNodeId(node.getNodeId())
- .setOduInterfaceId(createdOdu4Interfaces);
+ .setOduInterfaceId(createdOduc4Interfaces); // though this is odu, actually it has ODUC4 interfaces
nodeInterfaces.add(nodeInterfaceBuilder.build());
- otnNodesProvisioned.add(node);
+ LinkTp otnLinkTp = new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build();
+ linkTpList.add(otnLinkTp);
}
}
- private void updateOtnTopology(CopyOnWriteArrayList<Nodes> nodes, List<String> nodesTps, String serviceRate,
- Short tribPortNb, Short tribSlotNb, boolean isDeletion) {
- if (nodes != null && nodes.size() == 2) {
- if (isDeletion) {
- LOG.info("updating otn-topology removing ODU4 links");
- this.networkModelService.deleteOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(),
- nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4);
+ private void createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
+ CopyOnWriteArrayList<LinkTp> linkTpList) throws OpenRoadmInterfaceException {
+ if (input.getNodes() == null) {
+ return;
+ }
+ LOG.info("Creation of ODU4 tp interface {}", input);
+ for (int i = 0; i < input.getNodes().size(); i++) {
+ Nodes node = input.getNodes().get(i);
+ String supportingOtuInterface = node.getNetworkTp() + "-OTU";
+ List<String> createdOdu4Interfaces = new ArrayList<>();
+ // Adding SAPI/DAPI information to the
+ Nodes tgtNode = null;
+ if (i + 1 == input.getNodes().size()) {
+ // For the end node, tgtNode becomes the first node in the list
+ tgtNode = input.getNodes().get(0);
} else {
- LOG.info("updating otn-topology adding ODU4 links");
- this.networkModelService.createOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getNetworkTp(),
- nodes.get(1).getNodeId(), nodes.get(1).getNetworkTp(), OtnLinkType.ODTU4);
+ tgtNode = input.getNodes().get(i + 1);
}
- } else if (nodesTps != null && (nodesTps.size() % 2 == 0) && serviceRate != null && tribPortNb != null
- && tribSlotNb != null) {
- LOG.info("updating otn-topology node tps -tps and tpn pools");
- this.networkModelService.updateOtnLinks(nodesTps, serviceRate, tribPortNb, tribSlotNb, isDeletion);
+
+ createdOdu4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(node.getNodeId(),
+ node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
+ NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
+ .withKey(new NodeInterfaceKey(node.getNodeId()))
+ .setNodeId(node.getNodeId())
+ .setOduInterfaceId(createdOdu4Interfaces);
+ nodeInterfaces.add(nodeInterfaceBuilder.build());
+ LinkTp otnLinkTp = new LinkTpBuilder().setNodeId(node.getNodeId()).setTpId(node.getNetworkTp()).build();
+ linkTpList.add(otnLinkTp);
}
}
-
}