ServiceDataStoreOperations serviceDataStoreOperations = new ServiceDataStoreOperationsImpl(
lightyServices.getBindingDataBroker());
RendererListenerImpl rendererListenerImpl = new RendererListenerImpl(pathComputationService,
- lightyServices.getBindingNotificationPublishService());
+ lightyServices.getBindingNotificationPublishService(), networkModelService);
PceListenerImpl pceListenerImpl = new PceListenerImpl(rendererServiceOperations, pathComputationService,
lightyServices.getBindingNotificationPublishService(), serviceDataStoreOperations);
NetworkModelListenerImpl networkModelListenerImpl = new NetworkModelListenerImpl(
*/
package org.opendaylight.transportpce.networkmodel.service;
-import java.util.List;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev210426.mapping.Mapping;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.renderer.rpc.result.sp.Link;
import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.urn.opendaylight.netconf.node.topology.rev150114.NetconfNodeConnectionStatus;
import org.opendaylight.yangtools.yang.common.Uint32;
/**
* update otn links from otn-topology.
*
- * @param nodeTps
- * List containing a string composed of the netconf nodeId , and the
- * termination point supporting the service
+ * @param link
+ * link containing termination points to be updated
* @param serviceRate
* Service rate may be 1G, 10G or 100G
* @param tribPortNb
* @param isDeletion
* True indicates if the low-order otn service must be deleted
*/
- void updateOtnLinks(List<String> nodeTps, Uint32 serviceRate, Short tribPortNb, Short tribSoltNb,
- boolean isDeletion);
+ void updateOtnLinks(Link link, Uint32 serviceRate, Short tribPortNb, Short tribSoltNb, boolean isDeletion);
}
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.Link1;
import org.opendaylight.yang.gen.v1.http.org.openroadm.otn.network.topology.rev200529.TerminationPoint1;
+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.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
}
@Override
- public void updateOtnLinks(List<String> nodeTps, Uint32 serviceRate, Short tribPortNb, Short tribSoltNb,
- boolean isDeletion) {
- List<Link> supportedOdu4Links = getSupportingOdu4Links(nodeTps);
- List<TerminationPoint> tps = getOtnNodeTps(nodeTps);
+ public void updateOtnLinks(
+ org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.renderer.rpc.result.sp.Link
+ notifLink, Uint32 serviceRate, Short tribPortNb, Short tribSoltNb, boolean isDeletion) {
+
+ LinkTp atermination = new LinkTpBuilder()
+ .setNodeId(notifLink.getATermination().getNodeId())
+ .setTpId(notifLink.getATermination().getTpId())
+ .build();
+ LinkTp ztermination = new LinkTpBuilder()
+ .setNodeId(notifLink.getZTermination().getNodeId())
+ .setTpId(notifLink.getZTermination().getTpId())
+ .build();
+ List<LinkTp> linkTerminations = new ArrayList<>();
+ linkTerminations.add(atermination);
+ linkTerminations.add(ztermination);
+
+ List<Link> supportedOdu4Links = getSupportingOdu4Links(linkTerminations);
+ List<TerminationPoint> tps = getOtnNodeTps(linkTerminations);
TopologyShard otnTopologyShard;
otnTopologyShard = OpenRoadmOtnTopology.updateOtnLinks(supportedOdu4Links, tps, serviceRate, tribPortNb,
tribSoltNb, isDeletion);
return tps;
}
- private List<TerminationPoint> getOtnNodeTps(List<String> nodeTopoTps) {
+ private List<TerminationPoint> getOtnNodeTps(List<LinkTp> linkTerminations) {
List<TerminationPoint> tps = new ArrayList<>();
- for (String str : nodeTopoTps) {
- String nodeId = str.split("--")[0];
- String tp = str.split("--")[1];
+ for (LinkTp linkTp : linkTerminations) {
+ String tp = linkTp.getTpId();
+ String nodeId = new StringBuilder(linkTp.getNodeId()).append("-")
+ .append(tp.split("-")[0]).toString();
InstanceIdentifier<TerminationPoint> iiTp = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID)))
.child(Node.class, new NodeKey(new NodeId(nodeId)))
}
}
- private List<Link> getSupportingOdu4Links(List<String> nodesTopoTps) {
+ private List<Link> getSupportingOdu4Links(List<LinkTp> nodesTopoTps) {
InstanceIdentifier<Network1> iiOtnTopologyLinks = InstanceIdentifier.builder(Networks.class)
.child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OTN_NETWORK_ID)))
.augmentation(Network1.class)
}
List<Link> links = new ArrayList<>();
if (odu4links != null) {
- for (String str : nodesTopoTps) {
- String[] nodeAndTp = str.split("--");
- if (nodeAndTp.length >= 2) {
- String nodeId = nodeAndTp[0];
- String tp = nodeAndTp[1];
- Link slink = odu4links.stream().filter(lk -> lk.getSource().getSourceNode().getValue()
- .equals(nodeId) && lk.getSource().getSourceTp().toString().equals(tp)).findFirst().get();
- if (!links.contains(slink)) {
- links.add(slink);
- }
- Link dlink = odu4links.stream().filter(lk -> lk.getDestination().getDestNode().getValue()
- .equals(nodeId) && lk.getDestination().getDestTp().toString().equals(tp)).findFirst().get();
- if (!links.contains(dlink)) {
- links.add(dlink);
- }
+ for (LinkTp linkTp : nodesTopoTps) {
+ String tp = linkTp.getTpId();
+ String nodeId = new StringBuilder(linkTp.getNodeId()).append("-")
+ .append(tp.split("-")[0]).toString();
+ Link slink = odu4links.stream().filter(lk -> lk.getSource().getSourceNode().getValue()
+ .equals(nodeId) && lk.getSource().getSourceTp().toString().equals(tp)).findFirst().get();
+ if (!links.contains(slink)) {
+ links.add(slink);
+ }
+ Link dlink = odu4links.stream().filter(lk -> lk.getDestination().getDestNode().getValue()
+ .equals(nodeId) && lk.getDestination().getDestTp().toString().equals(tp)).findFirst().get();
+ if (!links.contains(dlink)) {
+ links.add(dlink);
}
}
LOG.debug("odu4links = {}", links.toString());
}
public static ServicePathInputData rendererCreateServiceInputAToZ(String serviceName,
- PathDescription pathDescription) {
+ PathDescription pathDescription, Action operation) {
int scale = GridConstant.FIXED_GRID_FREQUENCY_PRECISION;
AToZDirection atoZDirection = pathDescription.getAToZDirection();
LOG.info("Building ServicePathInputData for a to z direction {}", atoZDirection);
NodeLists nodeLists = getNodesListAToZ(atoZDirection.nonnullAToZ().values().iterator());
ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
.setServiceName(serviceName)
- .setOperation(Action.Create)
+ .setOperation(operation)
.setNodes(nodeLists.getRendererNodeList())
.setWidth(new FrequencyGHz(GridConstant.WIDTH_40));
if (atoZDirection.getAToZWavelengthNumber() != null) {
}
public static ServicePathInputData rendererCreateServiceInputZToA(String serviceName,
- PathDescription pathDescription) {
+ PathDescription pathDescription, Action operation) {
int scale = GridConstant.FIXED_GRID_FREQUENCY_PRECISION;
ZToADirection ztoADirection = pathDescription.getZToADirection();
LOG.info("Building ServicePathInputData for z to a direction {}", ztoADirection);
NodeLists nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
ServicePathInputBuilder servicePathInputBuilder = new ServicePathInputBuilder()
- .setOperation(Action.Create)
+ .setOperation(operation)
.setServiceName(serviceName)
.setNodes(nodeLists.getRendererNodeList())
.setWidth(new FrequencyGHz(GridConstant.WIDTH_40));
}
// Adding createOtnServiceInputpath for A-Z and Z-A directions as one method
- public static OtnServicePathInput rendererCreateOtnServiceInput(String serviceName, String serviceFormat,
- Uint32 serviceRate, PathDescription pathDescription, boolean asideToZside) {
+ public static OtnServicePathInput rendererCreateOtnServiceInput(String serviceName, Action operation,
+ String serviceFormat, Uint32 serviceRate, PathDescription pathDescription, boolean asideToZside) {
// 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.rev210618.otn.renderer.nodes.Nodes> nodes =
new ArrayList<>();
- NodeLists nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().nonnullAToZ().values().iterator());
- if (!asideToZside) {
+ NodeLists nodeLists;
+ if (asideToZside) {
+ nodeLists = getNodesListAToZ(pathDescription.getAToZDirection().nonnullAToZ().values().iterator());
+ } else {
nodeLists = getNodesListZtoA(pathDescription.getZToADirection().nonnullZToA().values().iterator());
}
LOG.info("These are node-lists {}, {}", nodeLists.getRendererNodeList(), nodeLists.getOlmNodeList());
}
OtnServicePathInputBuilder otnServicePathInputBuilder = new OtnServicePathInputBuilder()
.setServiceName(serviceName)
+ .setOperation(operation)
.setServiceFormat(serviceFormat)
.setServiceRate(serviceRate)
.setNodes(nodes);
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.Services;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.ServicesBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.ServicesKey;
+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.optical.renderer.nodes.Nodes;
-import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
ConcurrentLinkedQueue<String> results = new ConcurrentLinkedQueue<>();
Map<NodeInterfaceKey,NodeInterface> nodeInterfaces = new ConcurrentHashMap<>();
Set<String> nodesProvisioned = Sets.newConcurrentHashSet();
- CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
+ CopyOnWriteArrayList<LinkTp> otnLinkTps = new CopyOnWriteArrayList<>();
ServiceListTopology topology = new ServiceListTopology();
AtomicBoolean success = new AtomicBoolean(true);
ForkJoinPool forkJoinPool = new ForkJoinPool();
tgtNode.getNodeId(), tgtNode.getDestTp());
createdOtuInterfaces.add(supportingOtuInterface);
if (srcTp == null) {
- otnNodesProvisioned.add(node);
+ LinkTp linkTp = new LinkTpBuilder()
+ .setNodeId(nodeId)
+ .setTpId(destTp)
+ .build();
+ otnLinkTps.add(linkTp);
} else {
createdOduInterfaces.add(this.openRoadmInterfaceFactory.createOpenRoadmOdu4Interface(nodeId,
destTp, supportingOtuInterface));
// setting topology in the service list data store
try {
setTopologyForService(input.getServiceName(), topology.getTopology());
- updateOtnTopology(otnNodesProvisioned, false);
} catch (InterruptedException | TimeoutException | ExecutionException e) {
LOG.warn("Failed to write topologies for service {}.", input.getServiceName(), e);
}
ServicePathOutputBuilder setServBldr = new ServicePathOutputBuilder()
.setNodeInterface(nodeInterfaces)
.setSuccess(success.get())
- .setResult(String.join("\n", results));
+ .setResult(String.join("\n", results))
+ .setLinkTp(otnLinkTps);
return setServBldr.build();
}
if (!alarmSuppressionNodeRegistration(input)) {
LOG.warn("Alarm suppresion node registraion failed!!!!");
}
- 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<>();
srcTp = node.getSrcTp();
} else {
srcTp = "";
- otnNodesProvisioned.add(node);
+ LinkTp linkTp = new LinkTpBuilder()
+ .setNodeId(nodeId)
+ .setTpId(destTp)
+ .build();
+ otnLinkTps.add(linkTp);
}
// if the node is currently mounted then proceed.
if (this.deviceTransactionManager.isDeviceMounted(nodeId)) {
LOG.error("Error while deleting service paths!", e);
}
forkJoinPool.shutdown();
- updateOtnTopology(otnNodesProvisioned, true);
if (!alarmSuppressionNodeRemoval(input.getServiceName())) {
LOG.error("Alarm suppresion node removal failed!!!!");
}
- ServicePathOutputBuilder delServBldr = new ServicePathOutputBuilder();
- delServBldr.setSuccess(success.get());
+ ServicePathOutputBuilder delServBldr = new ServicePathOutputBuilder()
+ .setSuccess(success.get())
+ .setLinkTp(otnLinkTps);
if (results.isEmpty()) {
return delServBldr.setResult("Request processed").build();
} else {
}
return result;
}
-
- private void updateOtnTopology(CopyOnWriteArrayList<Nodes> nodes, boolean isDeletion) {
- if (nodes.size() != 2) {
- LOG.error("Error with OTU4 links to update in otn-topology");
- return;
- }
- if (isDeletion) {
- LOG.info("updating otn-topology removing OTU4 links");
- this.networkModelService.deleteOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getDestTp(),
- nodes.get(1).getNodeId(), nodes.get(1).getDestTp(), OtnLinkType.OTU4);
- } else {
- LOG.info("updating otn-topology adding OTU4 links");
- this.networkModelService.createOtnLinks(nodes.get(0).getNodeId(), nodes.get(0).getDestTp(),
- nodes.get(1).getNodeId(), nodes.get(1).getDestTp(), OtnLinkType.OTU4);
- }
- }
}
import java.util.Collections;
import java.util.List;
import org.opendaylight.transportpce.common.OperationResult;
+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.node.interfaces.NodeInterface;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.optical.renderer.nodes.Nodes;
private final List<Nodes> olmList;
private final List<NodeInterface> renderedNodeInterfaces;
+ private final List<LinkTp> otnLinkTps;
private DeviceRenderingResult(boolean success, String message, List<Nodes> olmList,
- List<NodeInterface> renderedNodeInterfaces) {
+ List<NodeInterface> renderedNodeInterfaces, List<LinkTp> otnLinkTps) {
super(success, message);
if (olmList != null) {
this.olmList = Collections.unmodifiableList(olmList);
} else {
this.olmList = Collections.emptyList();
}
-
if (renderedNodeInterfaces != null) {
this.renderedNodeInterfaces = Collections.unmodifiableList(renderedNodeInterfaces);
} else {
this.renderedNodeInterfaces = Collections.emptyList();
}
+ if (otnLinkTps != null) {
+ this.otnLinkTps = Collections.unmodifiableList(otnLinkTps);
+ } else {
+ this.otnLinkTps = Collections.emptyList();
+ }
}
public List<Nodes> getOlmList() {
return this.renderedNodeInterfaces;
}
+ public List<LinkTp> getOtnLinkTps() {
+ return this.otnLinkTps;
+ }
+
public static DeviceRenderingResult failed(String message) {
- return new DeviceRenderingResult(false, message, null, null);
+ return new DeviceRenderingResult(false, message, null, null, null);
}
- public static DeviceRenderingResult ok(List<Nodes> olmList, List<NodeInterface> renderedNodeInterfaces) {
- return new DeviceRenderingResult(true, "", olmList, renderedNodeInterfaces);
+ public static DeviceRenderingResult ok(List<Nodes> olmNodeList, List<NodeInterface> renderedNodeInterfaces,
+ List<LinkTp> otnLinkTps) {
+ return new DeviceRenderingResult(true, "", olmNodeList, renderedNodeInterfaces, otnLinkTps);
}
}
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.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.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
-import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
.setResult("Error - service-type and service-rate must be presents");
return otnServicePathOutputBuilder.build();
}
- CopyOnWriteArrayList<Nodes> otnNodesProvisioned = new CopyOnWriteArrayList<>();
- switch (input.getServiceFormat()) {
- case "Ethernet":
- if (input.getServiceRate().intValue() == 1 || input.getServiceRate().intValue() == 10) {
- try {
- LOG.info("Calling Node interfaces {} {} {} {} {} {} {}",
- input.getServiceRate(), input.getEthernetEncoding(),
- input.getServiceFormat(), 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 = updateOduNodes(nodeInterfaces, "ODU");
- updateOtnTopology(null, nodesToUpdate, input.getServiceRate(), input.getTribPortNumber(),
- input.getTribSlot(), false);
- } catch (OpenRoadmInterfaceException e) {
- LOG.warn("Set up service path failed", e);
- success = false;
- }
- } else if (input.getServiceRate().intValue() == 100) {
- try {
- LOG.info("Calling Node interfaces {} {} {} {} {} {}",
- input.getServiceRate(), input.getEthernetEncoding(),
- input.getServiceFormat(), input.getOperation(), input.getOpucnTribSlots(),
- input.getNodes());
- nodeInterfaces = createInterface(input);
- LOG.info("Node interfaces created just fine for 100G OTN ");
- // TODO: Update the OTN topology accordingly with Opucn-Trib-slots
- // List<String> nodesToUpdate = updateOduNodes(nodeInterfaces, "ODUC4");
- // 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 (input.getServiceRate().intValue() == 100) {
- 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 if (input.getServiceRate().intValue() == 400) {
- try {
- createOduc4TtpInterface(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.getServiceFormat());
+ 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<>();
case 100:
if ("ODU".equals(input.getServiceFormat())) {
interfacesToDelete.add(networkTp + "-ODU4");
- otnNodesProvisioned.add(node);
if (node.getNetwork2Tp() != null) {
interfacesToDelete.add(node.getNetwork2Tp() + "-ODU4");
}
case 400:
if ("ODU".equals(input.getServiceFormat())) {
interfacesToDelete.add(networkTp + "-ODUC4");
- otnNodesProvisioned.add(node);
if (node.getNetwork2Tp() != null) {
interfacesToDelete.add(node.getNetwork2Tp() + "-ODUC4");
}
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.getServiceFormat())) {
- 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 List<String> updateOduNodes(List<NodeInterface> nodeInterfaceList, String deLimiter) {
- List<String> nodesToUpdate = new ArrayList<>();
- if (!(deLimiter.equals("ODU")) || !(deLimiter.equals("ODUC4"))) {
- LOG.error("ODU node list update will be incorrect");
- }
-
- if (!nodeInterfaceList.isEmpty()) {
- for (NodeInterface nodeInterf : nodeInterfaceList) {
- 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("-" + deLimiter)[0];
- String nodeTopo = nodeInterf.getNodeId() + "-" + tp.split("-")[0];
- nodesToUpdate.add(nodeTopo + "--" + tp);
- }
- }
- }
- }
- }
-
- return nodesToUpdate;
- }
-
- 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
- || !(input.getServiceRate().intValue() == 1 || input.getServiceRate().intValue() == 10
- || input.getServiceRate().intValue() == 100)) {
- 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<>();
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 10:
// 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:
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) {
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 createOduc4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
- CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
+ CopyOnWriteArrayList<LinkTp> linkTpList) throws OpenRoadmInterfaceException {
if (input.getNodes() == null) {
return;
}
.setNodeId(node.getNodeId())
.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 createODU4TtpInterface(OtnServicePathInput input, List<NodeInterface> nodeInterfaces,
- CopyOnWriteArrayList<Nodes> otnNodesProvisioned) throws OpenRoadmInterfaceException {
+ CopyOnWriteArrayList<LinkTp> linkTpList) throws OpenRoadmInterfaceException {
if (input.getNodes() == null) {
return;
}
} else {
tgtNode = input.getNodes().get(i + 1);
}
+
createdOdu4Interfaces.add(openRoadmInterfaceFactory.createOpenRoadmOtnOdu4Interface(node.getNodeId(),
node.getNetworkTp(), supportingOtuInterface, tgtNode.getNodeId(), tgtNode.getNetworkTp()));
NodeInterfaceBuilder nodeInterfaceBuilder = new NodeInterfaceBuilder()
.setNodeId(node.getNodeId())
.setOduInterfaceId(createdOdu4Interfaces);
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, Uint32 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);
- } 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);
- }
- } 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);
- }
- }
-
}
import java.util.Collections;
import java.util.List;
import org.opendaylight.transportpce.common.OperationResult;
+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.node.interfaces.NodeInterface;
public final class OtnDeviceRenderingResult extends OperationResult {
private final List<NodeInterface> renderedNodeInterfaces;
+ private final List<LinkTp> otnLinkTps;
- private OtnDeviceRenderingResult(boolean success, String message, List<NodeInterface> renderedNodeInterfaces) {
+
+ private OtnDeviceRenderingResult(boolean success, String message, List<NodeInterface> renderedNodeInterfaces,
+ List<LinkTp> otnLinkTps) {
super(success, message);
if (renderedNodeInterfaces != null) {
this.renderedNodeInterfaces = Collections.unmodifiableList(renderedNodeInterfaces);
} else {
this.renderedNodeInterfaces = Collections.emptyList();
}
+ if (otnLinkTps != null) {
+ this.otnLinkTps = Collections.unmodifiableList(otnLinkTps);
+ } else {
+ this.otnLinkTps = Collections.emptyList();
+ }
}
public List<NodeInterface> getRenderedNodeInterfaces() {
return this.renderedNodeInterfaces;
}
+ public List<LinkTp> getOtnLinkTps() {
+ return this.otnLinkTps;
+ }
+
public static OtnDeviceRenderingResult failed(String message) {
- return new OtnDeviceRenderingResult(false, message, null);
+ return new OtnDeviceRenderingResult(false, message, null, null);
}
- public static OtnDeviceRenderingResult ok(List<NodeInterface> renderedNodeInterfaces) {
- return new OtnDeviceRenderingResult(true, "", renderedNodeInterfaces);
+ public static OtnDeviceRenderingResult ok(List<NodeInterface> renderedNodeInterfaces,
+ List<LinkTp> otnLinkTps) {
+ return new OtnDeviceRenderingResult(true, "", renderedNodeInterfaces, otnLinkTps);
}
}
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.OlmPowerSetupTask;
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.OtnDeviceRenderingTask;
import org.opendaylight.transportpce.renderer.provisiondevice.tasks.RollbackProcessor;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.device.renderer.rev210618.Action;
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.olm.rev210618.GetPmInputBuilder;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.GetPmOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.olm.rev210618.ServicePowerSetupInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.ServiceDeleteOutput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.ServiceImplementationRequestInput;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.ServiceImplementationRequestOutput;
-import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ConnectionType;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.link._for.notif.ATerminationBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.link._for.notif.ZTerminationBuilder;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.renderer.rpc.result.sp.Link;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.renderer.rpc.result.sp.LinkBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.NodeTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.pm.types.rev161014.PmGranularity;
import org.opendaylight.yang.gen.v1.http.org.openroadm.resource.types.rev161014.ResourceTypeEnum;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.ServicePathList;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.service.path.list.ServicePaths;
import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.servicepath.rev171017.service.path.list.ServicePathsKey;
+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.olm.get.pm.input.ResourceIdentifierBuilder;
import org.opendaylight.yang.gen.v1.http.org.transportpce.common.types.rev210618.optical.renderer.nodes.Nodes;
import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
case StringConstants.SERVICE_TYPE_400GE:
case StringConstants.SERVICE_TYPE_OTU4:
case StringConstants.SERVICE_TYPE_OTUC4:
- if (!manageServicePathCreation(input)) {
+ if (!manageServicePathCreation(input, serviceType)) {
return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
OPERATION_FAILED);
}
break;
case StringConstants.SERVICE_TYPE_1GE:
case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_100GE_M:
case StringConstants.SERVICE_TYPE_ODU4:
case StringConstants.SERVICE_TYPE_ODUC4:
- // This is A-Z side
- OtnServicePathInput otnServicePathInputAtoZ = ModelMappingUtils
- .rendererCreateOtnServiceInput(input.getServiceName(),
- input.getServiceAEnd().getServiceFormat().getName(),
- serviceRate,
- input.getPathDescription(), true);
- // This is Z-A side
- OtnServicePathInput otnServicePathInputZtoA = ModelMappingUtils
- .rendererCreateOtnServiceInput(input.getServiceName(),
- input.getServiceZEnd().getServiceFormat().getName(),
- serviceRate,
- input.getPathDescription(), false);
- // Rollback should be same for all conditions, so creating a new one
- RollbackProcessor rollbackProcessor = new RollbackProcessor();
- otnDeviceRendering(rollbackProcessor, otnServicePathInputAtoZ, otnServicePathInputZtoA);
- if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
- input.getServiceName(), RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
+ if (!manageOtnServicePathCreation(input, serviceType, serviceRate)) {
return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_FAILED,
OPERATION_FAILED);
}
LOG.error("unsupported service-type");
break;
}
-
- sendNotificationsWithPathDescription(
- ServicePathNotificationTypes.ServiceImplementationRequest,
- input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL,
- input.getPathDescription());
return ModelMappingUtils.createServiceImplResponse(ResponseCodes.RESPONSE_OK,
OPERATION_SUCCESSFUL);
}
case StringConstants.SERVICE_TYPE_400GE:
case StringConstants.SERVICE_TYPE_OTU4:
case StringConstants.SERVICE_TYPE_OTUC4:
- if (!manageServicePathDeletion(serviceName, pathDescription)) {
+ if (!manageServicePathDeletion(serviceName, pathDescription, serviceType)) {
return ModelMappingUtils.createServiceDeleteResponse(ResponseCodes.RESPONSE_FAILED,
OPERATION_FAILED);
}
break;
case StringConstants.SERVICE_TYPE_1GE:
case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_100GE_M:
case StringConstants.SERVICE_TYPE_ODU4:
case StringConstants.SERVICE_TYPE_ODUC4:
- if (!manageOtnServicePathDeletion(serviceName, pathDescription, service)) {
+ if (!manageOtnServicePathDeletion(serviceName, pathDescription, service, serviceType)) {
return ModelMappingUtils.createServiceDeleteResponse(ResponseCodes.RESPONSE_FAILED,
OPERATION_FAILED);
}
RENDERING_DEVICES_A_Z_MSG);
ListenableFuture<OtnDeviceRenderingResult> atozrenderingFuture =
this.executor.submit(new OtnDeviceRenderingTask(this.otnDeviceRenderer, otnServicePathAtoZ));
- ListenableFuture<List<OtnDeviceRenderingResult>> renderingCombinedFuture;
- if (otnServicePathZtoA != null) {
- LOG.info("Rendering devices Z-A");
- sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
- otnServicePathZtoA.getServiceName(), RpcStatusEx.Pending,
- RENDERING_DEVICES_Z_A_MSG);
- ListenableFuture<OtnDeviceRenderingResult> ztoarenderingFuture =
- this.executor.submit(new OtnDeviceRenderingTask(this.otnDeviceRenderer, otnServicePathZtoA));
- renderingCombinedFuture = Futures.allAsList(atozrenderingFuture, ztoarenderingFuture);
- } else {
- renderingCombinedFuture = Futures.allAsList(atozrenderingFuture);
- }
+ LOG.info("Rendering devices Z-A");
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ otnServicePathZtoA.getServiceName(), RpcStatusEx.Pending,
+ RENDERING_DEVICES_Z_A_MSG);
+ ListenableFuture<OtnDeviceRenderingResult> ztoarenderingFuture =
+ this.executor.submit(new OtnDeviceRenderingTask(this.otnDeviceRenderer, otnServicePathZtoA));
+ ListenableFuture<List<OtnDeviceRenderingResult>> renderingCombinedFuture =
+ Futures.allAsList(atozrenderingFuture, ztoarenderingFuture);
List<OtnDeviceRenderingResult> otnRenderingResults = new ArrayList<>(2);
try {
LOG.info("Waiting for A-Z and Z-A device renderers ...");
@edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
value = "UPM_UNCALLED_PRIVATE_METHOD",
justification = "call in call() method")
- private boolean manageServicePathCreation(ServiceImplementationRequestInput input) {
+ private boolean manageServicePathCreation(ServiceImplementationRequestInput input, String serviceType) {
ServicePathInputData servicePathInputDataAtoZ = ModelMappingUtils
- .rendererCreateServiceInputAToZ(input.getServiceName(), input.getPathDescription());
+ .rendererCreateServiceInputAToZ(input.getServiceName(), input.getPathDescription(), Action.Create);
ServicePathInputData servicePathInputDataZtoA = ModelMappingUtils
- .rendererCreateServiceInputZToA(input.getServiceName(), input.getPathDescription());
+ .rendererCreateServiceInputZToA(input.getServiceName(), input.getPathDescription(), Action.Create);
// Rollback should be same for all conditions, so creating a new one
RollbackProcessor rollbackProcessor = new RollbackProcessor();
List<DeviceRenderingResult> renderingResults =
"Service activation test failed.");
return false;
}
+ List<LinkTp> otnLinkTerminationPoints = new ArrayList<>();
+ renderingResults.forEach(rr -> otnLinkTerminationPoints.addAll(rr.getOtnLinkTps()));
+ Link notifLink = createLinkForNotif(otnLinkTerminationPoints);
+
sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceImplementationRequest,
- input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL, input.getPathDescription());
+ input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL, input.getPathDescription(),
+ notifLink, serviceType);
return true;
}
@edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
value = "UPM_UNCALLED_PRIVATE_METHOD",
justification = "call in call() method")
- private boolean manageServicePathDeletion(String serviceName, PathDescription pathDescription) {
+ private boolean manageServicePathDeletion(String serviceName, PathDescription pathDescription, String serviceType)
+ throws InterruptedException {
ServicePathInputData servicePathInputDataAtoZ =
- ModelMappingUtils.rendererCreateServiceInputAToZ(serviceName, pathDescription);
+ ModelMappingUtils.rendererCreateServiceInputAToZ(serviceName, pathDescription, Action.Delete);
ServicePathInputData servicePathInputDataZtoA =
- ModelMappingUtils.rendererCreateServiceInputZToA(serviceName, pathDescription);
+ ModelMappingUtils.rendererCreateServiceInputZToA(serviceName, pathDescription, Action.Delete);
// OLM turn down power
try {
LOG.debug(TURNING_DOWN_POWER_ON_A_TO_Z_PATH_MSG);
LOG.info("Deleting service path via renderer");
sendNotifications(ServicePathNotificationTypes.ServiceDelete, serviceName, RpcStatusEx.Pending,
"Deleting service path via renderer");
- deviceRenderer.deleteServicePath(servicePathInputDataAtoZ.getServicePathInput());
- deviceRenderer.deleteServicePath(servicePathInputDataZtoA.getServicePathInput());
+ RollbackProcessor rollbackProcessor = new RollbackProcessor();
+ List<DeviceRenderingResult> renderingResults =
+ deviceRendering(rollbackProcessor, servicePathInputDataAtoZ, servicePathInputDataZtoA);
+ List<LinkTp> otnLinkTerminationPoints = new ArrayList<>();
+ renderingResults.forEach(rr -> otnLinkTerminationPoints.addAll(rr.getOtnLinkTps()));
+ Link notifLink = createLinkForNotif(otnLinkTerminationPoints);
+
sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceDelete,
- serviceName, RpcStatusEx.Successful, OPERATION_SUCCESSFUL,pathDescription);
+ serviceName, RpcStatusEx.Successful, OPERATION_SUCCESSFUL, pathDescription, notifLink, serviceType);
+ return true;
+ }
+
+ @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(
+ value = "UPM_UNCALLED_PRIVATE_METHOD",
+ justification = "call in call() method")
+ private boolean manageOtnServicePathCreation(ServiceImplementationRequestInput input, String serviceType,
+ Uint32 serviceRate) {
+ // This is A-Z side
+ OtnServicePathInput otnServicePathInputAtoZ = ModelMappingUtils
+ .rendererCreateOtnServiceInput(input.getServiceName(), Action.Create,
+ input.getServiceAEnd().getServiceFormat().getName(),
+ serviceRate,
+ input.getPathDescription(), true);
+ // This is Z-A side
+ OtnServicePathInput otnServicePathInputZtoA = ModelMappingUtils
+ .rendererCreateOtnServiceInput(input.getServiceName(), Action.Create,
+ input.getServiceZEnd().getServiceFormat().getName(),
+ serviceRate,
+ input.getPathDescription(), false);
+ // Rollback should be same for all conditions, so creating a new one
+ RollbackProcessor rollbackProcessor = new RollbackProcessor();
+ List<OtnDeviceRenderingResult> renderingResults =
+ otnDeviceRendering(rollbackProcessor, otnServicePathInputAtoZ, otnServicePathInputZtoA);
+ if (rollbackProcessor.rollbackAllIfNecessary() > 0) {
+ rollbackProcessor.rollbackAll();
+ sendNotifications(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Failed, DEVICE_RENDERING_ROLL_BACK_MSG);
+ return false;
+ }
+ List<LinkTp> otnLinkTerminationPoints = new ArrayList<>();
+ renderingResults.forEach(rr -> otnLinkTerminationPoints.addAll(rr.getOtnLinkTps()));
+ Link notifLink = createLinkForNotif(otnLinkTerminationPoints);
+
+ sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceImplementationRequest,
+ input.getServiceName(), RpcStatusEx.Successful, OPERATION_SUCCESSFUL, input.getPathDescription(),
+ notifLink, serviceType);
return true;
}
value = "UPM_UNCALLED_PRIVATE_METHOD",
justification = "call in call() method")
private boolean manageOtnServicePathDeletion(String serviceName, PathDescription pathDescription,
- Services service) {
- OtnServicePathInput ospi = null;
- if (ConnectionType.Infrastructure.equals(service.getConnectionType())) {
- ospi = ModelMappingUtils.rendererCreateOtnServiceInput(
- serviceName, service.getServiceAEnd().getServiceFormat().getName(), Uint32.valueOf(100),
- pathDescription, true);
- } else if (ConnectionType.Service.equals(service.getConnectionType())) {
- ospi = ModelMappingUtils.rendererCreateOtnServiceInput(serviceName,
+ Services service, String serviceType) {
+ // This is A-Z side
+ OtnServicePathInput otnServicePathInputAtoZ = ModelMappingUtils
+ .rendererCreateOtnServiceInput(serviceName, Action.Delete,
service.getServiceAEnd().getServiceFormat().getName(),
- service.getServiceAEnd().getServiceRate(), pathDescription, true);
- }
+ service.getServiceAEnd().getServiceRate(),
+ pathDescription, true);
+ // This is Z-A side
+ OtnServicePathInput otnServicePathInputZtoA = ModelMappingUtils
+ .rendererCreateOtnServiceInput(serviceName, Action.Delete,
+ service.getServiceZEnd().getServiceFormat().getName(),
+ service.getServiceAEnd().getServiceRate(),
+ pathDescription, false);
LOG.info("Deleting otn-service path {} via renderer", serviceName);
sendNotifications(ServicePathNotificationTypes.ServiceDelete, serviceName, RpcStatusEx.Pending,
"Deleting otn-service path via renderer");
- OtnServicePathOutput result = otnDeviceRenderer.deleteOtnServicePath(ospi);
- if (result.getSuccess()) {
- sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceDelete,
- serviceName, RpcStatusEx.Successful, OPERATION_SUCCESSFUL, pathDescription);
- return true;
- } else {
- return false;
- }
+
+ RollbackProcessor rollbackProcessor = new RollbackProcessor();
+ List<OtnDeviceRenderingResult> renderingResults =
+ otnDeviceRendering(rollbackProcessor, otnServicePathInputAtoZ, otnServicePathInputZtoA);
+
+ List<LinkTp> otnLinkTerminationPoints = new ArrayList<>();
+ renderingResults.forEach(rr -> otnLinkTerminationPoints.addAll(rr.getOtnLinkTps()));
+ Link notifLink = createLinkForNotif(otnLinkTerminationPoints);
+
+ sendNotificationsWithPathDescription(ServicePathNotificationTypes.ServiceDelete,
+ serviceName, RpcStatusEx.Successful, OPERATION_SUCCESSFUL, pathDescription, notifLink, serviceType);
+ return true;
}
/**
private void sendNotifications(ServicePathNotificationTypes servicePathNotificationTypes, String serviceName,
RpcStatusEx rpcStatusEx, String message) {
Notification notification = buildNotification(servicePathNotificationTypes, serviceName, rpcStatusEx, message,
- null);
+ null, null, null);
send(notification);
}
* @param pathDescription PathDescription
*/
private void sendNotificationsWithPathDescription(ServicePathNotificationTypes servicePathNotificationTypes,
- String serviceName, RpcStatusEx rpcStatusEx, String message, PathDescription pathDescription) {
+ String serviceName, RpcStatusEx rpcStatusEx, String message, PathDescription pathDescription,
+ Link notifLink, String serviceType) {
Notification notification = buildNotification(servicePathNotificationTypes, serviceName, rpcStatusEx, message,
- pathDescription);
+ pathDescription, notifLink, serviceType);
send(notification);
}
* @return notification with RendererRpcResultSp type.
*/
private RendererRpcResultSp buildNotification(ServicePathNotificationTypes servicePathNotificationTypes,
- String serviceName, RpcStatusEx rpcStatusEx, String message, PathDescription pathDescription) {
+ String serviceName, RpcStatusEx rpcStatusEx, String message, PathDescription pathDescription,
+ Link notifLink, String serviceType) {
RendererRpcResultSpBuilder builder = new RendererRpcResultSpBuilder()
.setNotificationType(servicePathNotificationTypes).setServiceName(serviceName).setStatus(rpcStatusEx)
- .setStatusMessage(message);
+ .setStatusMessage(message)
+ .setServiceType(serviceType);
if (pathDescription != null) {
builder.setAToZDirection(pathDescription.getAToZDirection())
- .setZToADirection(pathDescription.getZToADirection());
+ .setZToADirection(pathDescription.getZToADirection());
+ }
+ if (notifLink != null) {
+ builder.setLink(notifLink);
}
return builder.build();
}
}
}
+ private Link createLinkForNotif(List<LinkTp> otnLinkTerminationPoints) {
+ if (otnLinkTerminationPoints.size() != 2 || otnLinkTerminationPoints.isEmpty()) {
+ return null;
+ } else {
+ return new LinkBuilder()
+ .setATermination(new ATerminationBuilder()
+ .setNodeId(otnLinkTerminationPoints.get(0).getNodeId())
+ .setTpId(otnLinkTerminationPoints.get(0).getTpId())
+ .build())
+ .setZTermination(new ZTerminationBuilder()
+ .setNodeId(otnLinkTerminationPoints.get(1).getNodeId())
+ .setTpId(otnLinkTerminationPoints.get(1).getTpId())
+ .build())
+ .build();
+ }
+ }
}
@Override
public DeviceRenderingResult call() throws Exception {
- ServicePathOutput output = this.deviceRenderer.setupServicePath(this.servicePathInputData.getServicePathInput(),
- this.direction);
- if (!output.getSuccess()) {
- LOG.warn("Device rendering not successfully finished.");
- return DeviceRenderingResult.failed("Operation Failed");
+ ServicePathOutput output;
+ switch (this.servicePathInputData.getServicePathInput().getOperation()) {
+ case Create:
+ output = this.deviceRenderer.setupServicePath(this.servicePathInputData.getServicePathInput(),
+ this.direction);
+ if (!output.getSuccess()) {
+ LOG.error("Device rendering setup service path failed.");
+ return DeviceRenderingResult.failed("Operation Failed");
+ }
+ List<Nodes> olmList = this.servicePathInputData.getNodeLists().getOlmNodeList();
+ LOG.info("Device rendering setup service path finished successfully.");
+ return DeviceRenderingResult.ok(olmList, new ArrayList<>(output.nonnullNodeInterface().values()),
+ new ArrayList<>(output.nonnullLinkTp()));
+ case Delete:
+ output = this.deviceRenderer.deleteServicePath(this.servicePathInputData.getServicePathInput());
+ if (!output.getSuccess()) {
+ LOG.error("Device rendering delete service path failed.");
+ return DeviceRenderingResult.failed("Operation Failed");
+ }
+ LOG.info("Device rendering delete service path finished successfully.");
+ return DeviceRenderingResult.ok(null, new ArrayList<>(output.nonnullNodeInterface().values()),
+ new ArrayList<>(output.nonnullLinkTp()));
+ default:
+ return DeviceRenderingResult.failed("Device rendering failed - unknwon operation");
}
- List<Nodes> olmList = this.servicePathInputData.getNodeLists().getOlmNodeList();
- LOG.info("Device rendering finished successfully.");
- return DeviceRenderingResult.ok(olmList, new ArrayList<>(output.nonnullNodeInterface().values()));
}
}
private final OtnServicePathInput otnServicePathInput;
public OtnDeviceRenderingTask(OtnDeviceRendererService otnDeviceRendererService,
- OtnServicePathInput otnServicePathInput) {
+ OtnServicePathInput otnServicePathInput) {
this.otnDeviceRenderer = otnDeviceRendererService;
this.otnServicePathInput = otnServicePathInput;
-
}
@Override
public OtnDeviceRenderingResult call() throws Exception {
- OtnServicePathOutput output = this.otnDeviceRenderer.setupOtnServicePath(this.otnServicePathInput);
- if (Boolean.TRUE.equals(output.getSuccess())) {
- LOG.info("Device rendering finished successfully.");
- return OtnDeviceRenderingResult.ok(new ArrayList<>(output.nonnullNodeInterface().values()));
-
- } else {
- //false or null case
- LOG.warn("Device rendering not successfully finished.");
- return OtnDeviceRenderingResult.failed("Operation Failed");
+ OtnServicePathOutput output;
+ switch (this.otnServicePathInput.getOperation()) {
+ case Create:
+ output = this.otnDeviceRenderer.setupOtnServicePath(this.otnServicePathInput);
+ if (!output.getSuccess()) {
+ LOG.error("Device rendering setup otn service path failed.");
+ return OtnDeviceRenderingResult.failed("Operation Failed");
+ }
+ LOG.info("Device rendering setup otn service path finished successfully.");
+ return OtnDeviceRenderingResult.ok(new ArrayList<>(output.nonnullNodeInterface().values()),
+ new ArrayList<>(output.nonnullLinkTp()));
+ case Delete:
+ output = this.otnDeviceRenderer.deleteOtnServicePath(this.otnServicePathInput);
+ if (!output.getSuccess()) {
+ LOG.error("Device rendering delete otn service path failed.");
+ return OtnDeviceRenderingResult.failed("Operation Failed");
+ }
+ LOG.info("Device rendering delete otn service path finished successfully.");
+ return OtnDeviceRenderingResult.ok(new ArrayList<>(output.nonnullNodeInterface().values()),
+ new ArrayList<>(output.nonnullLinkTp()));
+ default:
+ return OtnDeviceRenderingResult.failed("Device rendering failed - unknwon operation");
}
}
-
}
import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
import org.opendaylight.mdsal.binding.api.NotificationPublishService;
import org.opendaylight.transportpce.common.OperationResult;
+import org.opendaylight.transportpce.common.StringConstants;
+import org.opendaylight.transportpce.networkmodel.service.NetworkModelService;
import org.opendaylight.transportpce.pce.service.PathComputationService;
import org.opendaylight.transportpce.servicehandler.ServiceInput;
import org.opendaylight.transportpce.servicehandler.service.PCEServiceWrapper;
import org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperations;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.RendererRpcResultSp;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.TransportpceRendererListener;
+import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.renderer.rev210618.renderer.rpc.result.sp.Link;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultSh;
import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.servicehandler.rev201125.ServiceRpcResultShBuilder;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.service.types.rev190531.ServiceNotificationTypes;
import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
import org.opendaylight.yang.gen.v1.http.org.openroadm.service.rev190531.service.list.Services;
+import org.opendaylight.yang.gen.v1.http.transportpce.topology.rev210511.OtnLinkType;
import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.PublishNotificationService;
import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.PublishNotificationServiceBuilder;
import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.notification.service.ServiceAEndBuilder;
import org.opendaylight.yang.gen.v1.nbi.notifications.rev201130.notification.service.ServiceZEndBuilder;
+import org.opendaylight.yangtools.yang.common.Uint32;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
private PCEServiceWrapper pceServiceWrapper;
private Boolean tempService;
private NotificationPublishService notificationPublishService;
+ private final NetworkModelService networkModelService;
+
public RendererListenerImpl(PathComputationService pathComputationService,
- NotificationPublishService notificationPublishService) {
+ NotificationPublishService notificationPublishService, NetworkModelService networkModelService) {
this.pceServiceWrapper = new PCEServiceWrapper(pathComputationService, notificationPublishService);
setServiceInput(null);
setTempService(false);
this.notificationPublishService = notificationPublishService;
+ this.networkModelService = networkModelService;
}
@Override
switch (serviceRpcResultSp.getStatus()) {
case Successful:
LOG.info("Service '{}' deleted !", notification.getServiceName());
+ String serviceType = notification.getServiceType();
+ switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_1GE:
+ case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_100GE_M:
+ Short tribPort = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
+ .split("\\.")[0]);
+ Short minTribSlot = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
+ .split("\\.")[1]);
+ updateOtnTopology(notification.getLink(), true, notification.getServiceType(),
+ notification.getAToZDirection().getRate(), tribPort, minTribSlot);
+ break;
+ case StringConstants.SERVICE_TYPE_OTU4:
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ updateOtnTopology(notification.getLink(), true, notification.getServiceType(), null, null,
+ null);
+ break;
+ default:
+ break;
+ }
break;
case Failed:
LOG.error("Renderer service delete failed !");
LOG.debug("serviceDataStoreOperations is null");
return;
}
+ String serviceType = notification.getServiceType();
+ switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_1GE:
+ case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_100GE_M:
+ Short tribPort = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
+ .split("\\.")[0]);
+ Short minTribSlot = Short.valueOf(notification.getAToZDirection().getMinTribSlot().getValue()
+ .split("\\.")[1]);
+ updateOtnTopology(notification.getLink(), false, notification.getServiceType(),
+ notification.getAToZDirection().getRate(), tribPort, minTribSlot);
+ break;
+ case StringConstants.SERVICE_TYPE_OTU4:
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ updateOtnTopology(notification.getLink(), false, notification.getServiceType(), null, null, null);
+ break;
+ default:
+ break;
+ }
PublishNotificationServiceBuilder nbiNotificationBuilder = new PublishNotificationServiceBuilder()
.setServiceName(input.getServiceName())
.setServiceAEnd(new ServiceAEndBuilder(input.getServiceAEnd()).build())
.setCommonId(input.getCommonId()).setConnectionType(input.getConnectionType())
.setTopic(TOPIC);
OperationResult operationResult;
- String serviceType = "";
+ String serviceTemp = "";
if (tempService) {
operationResult = this.serviceDataStoreOperations.modifyTempService(
serviceRpcResultSp.getServiceName(), State.InService, AdminStates.InService);
- serviceType = "Temp ";
+ serviceTemp = "Temp ";
} else {
operationResult = this.serviceDataStoreOperations.modifyService(
serviceRpcResultSp.getServiceName(), State.InService, AdminStates.InService);
sendServiceHandlerNotification(notification, ServiceNotificationTypes.ServiceCreateResult);
}
} else {
- LOG.warn("{}Service status not updated in datastore !", serviceType);
+ LOG.warn("{}Service status not updated in datastore !", serviceTemp);
sendNbiNotification(nbiNotificationBuilder
- .setResponseFailed(serviceType + "Service status not updated in datastore !")
+ .setResponseFailed(serviceTemp + "Service status not updated in datastore !")
.setMessage("ServiceCreate request failed ...")
.setOperationalState(org.opendaylight.yang.gen.v1.http
.org.openroadm.common.state.types.rev181130.State.OutOfService)
Thread.currentThread().interrupt();
}
}
+
+ private void updateOtnTopology(Link link, boolean isDeletion, String serviceType, Uint32 rate, Short portNb,
+ Short slotNb) {
+ if (link == null) {
+ return;
+ }
+ OtnLinkType otnLinkType;
+ switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_OTU4:
+ otnLinkType = OtnLinkType.OTU4;
+ break;
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ otnLinkType = OtnLinkType.OTUC4;
+ break;
+ case StringConstants.SERVICE_TYPE_ODU4:
+ otnLinkType = OtnLinkType.ODTU4;
+ break;
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ otnLinkType = OtnLinkType.ODUC4;
+ break;
+ default:
+ otnLinkType = null;
+ LOG.warn("No otn-link-type corresponds to service-type {}", serviceType);
+ break;
+ }
+ switch (serviceType) {
+ case StringConstants.SERVICE_TYPE_OTU4:
+ case StringConstants.SERVICE_TYPE_OTUC4:
+ case StringConstants.SERVICE_TYPE_ODU4:
+ case StringConstants.SERVICE_TYPE_ODUC4:
+ if (isDeletion) {
+ LOG.info("updating otn-topology removing links");
+ this.networkModelService.deleteOtnLinks(link.getATermination().getNodeId(),
+ link.getATermination().getTpId(), link.getZTermination().getNodeId(),
+ link.getZTermination().getTpId(), otnLinkType);
+ } else {
+ LOG.info("updating otn-topology adding links");
+ this.networkModelService.createOtnLinks(link.getATermination().getNodeId(),
+ link.getATermination().getTpId(), link.getZTermination().getNodeId(),
+ link.getZTermination().getTpId(), otnLinkType);
+ }
+ break;
+ case StringConstants.SERVICE_TYPE_1GE:
+ case StringConstants.SERVICE_TYPE_10GE:
+ case StringConstants.SERVICE_TYPE_100GE_M:
+ LOG.info("updating otn-topology node tps -tps and tpn pools");
+ this.networkModelService.updateOtnLinks(link, rate, portNb, slotNb, isDeletion);
+ break;
+ default:
+ break;
+ }
+ }
+
}
<reference id="rendererServiceOperations"
interface="org.opendaylight.transportpce.renderer.provisiondevice.RendererServiceOperations" />
+ <reference id="networkModelService" interface="org.opendaylight.transportpce.networkmodel.service.NetworkModelService"/>
<bean id="serviceDatastoreOperation" class="org.opendaylight.transportpce.servicehandler.service.ServiceDataStoreOperationsImpl">
<argument ref="dataBroker"/>
<bean id="rendererListener" class="org.opendaylight.transportpce.servicehandler.listeners.RendererListenerImpl">
<argument ref="pathComputationService" />
<argument ref="notificationPublishService" />
+ <argument ref="networkModelService" />
</bean>
<bean id="networkModelListener" class="org.opendaylight.transportpce.servicehandler.listeners.NetworkModelListenerImpl">