2 * Copyright © 2021 Nokia, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.transportpce.tapi.listeners;
10 import edu.umd.cs.findbugs.annotations.SuppressFBWarnings;
11 import java.nio.charset.Charset;
12 import java.util.ArrayList;
13 import java.util.Comparator;
14 import java.util.HashMap;
15 import java.util.List;
17 import java.util.Optional;
18 import java.util.UUID;
19 import java.util.concurrent.ExecutionException;
20 import java.util.stream.Collectors;
21 import org.opendaylight.mdsal.binding.api.DataBroker;
22 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
23 import org.opendaylight.transportpce.common.network.NetworkTransactionImpl;
24 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
25 import org.opendaylight.transportpce.tapi.TapiStringConstants;
26 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.ServicePathRpcResult;
27 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.TransportpcePceListener;
28 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.service.path.rpc.result.PathDescription;
29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.pce.rev220808.service.path.rpc.result.PathDescriptionBuilder;
30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.Network;
31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.mapping.Mapping;
32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.mapping.MappingKey;
33 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.network.Nodes;
34 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220316.network.NodesKey;
35 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev211210.OpenroadmNodeType;
36 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev210705.path.description.atoz.direction.AToZ;
37 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev210705.pce.resource.resource.resource.Node;
38 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.pathdescription.rev210705.pce.resource.resource.resource.TerminationPoint;
39 import org.opendaylight.yang.gen.v1.http.org.transportpce.b.c._interface.service.types.rev220118.RpcStatusEx;
40 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Context;
41 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection;
42 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName;
43 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState;
44 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState;
45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortDirection;
46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.PortRole;
47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid;
48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name;
49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameBuilder;
50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameKey;
51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.Context1;
52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.CreateConnectivityServiceInput;
53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.OwnedNodeEdgePoint1;
54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.OwnedNodeEdgePoint1Builder;
55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPoint;
56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointBuilder;
57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointKey;
58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.LowerConnection;
59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.LowerConnectionBuilder;
60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.LowerConnectionKey;
61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.end.point.ClientNodeEdgePoint;
62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connection.end.point.ClientNodeEdgePointBuilder;
63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityService;
64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityServiceBuilder;
65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectivityServiceKey;
66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.Connection;
67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.ConnectionBuilder;
68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.service.ConnectionKey;
69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContextBuilder;
70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.topology.context.topology.node.owned.node.edge.point.CepList;
71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.topology.context.topology.node.owned.node.edge.point.CepListBuilder;
72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.context.TopologyContext;
73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint;
74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointBuilder;
75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey;
76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey;
77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.Topology;
78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.TopologyKey;
79 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
80 import org.slf4j.Logger;
81 import org.slf4j.LoggerFactory;
83 public class TapiPceListenerImpl implements TransportpcePceListener {
85 private static final Logger LOG = LoggerFactory.getLogger(TapiPceListenerImpl.class);
87 private final Uuid tapiTopoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
88 .getBytes(Charset.forName("UTF-8"))).toString());
89 private ServicePathRpcResult servicePathRpcResult;
90 private CreateConnectivityServiceInput input;
91 private Uuid serviceUuid;
92 private final DataBroker dataBroker;
93 private final NetworkTransactionService networkTransactionService;
94 private final Map<org.opendaylight.yang.gen.v1.urn
95 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionKey,
96 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection>
97 connectionFullMap; // this variable is for complete connection objects
98 private Connection topConnRdmRdm;
99 private Connection topConnXpdrXpdrPhtn;
100 private Connection topConnXpdrXpdrOdu;
102 public TapiPceListenerImpl(DataBroker dataBroker) {
103 this.connectionFullMap = new HashMap<>();
104 this.dataBroker = dataBroker;
105 this.networkTransactionService = new NetworkTransactionImpl(this.dataBroker);
106 this.topConnRdmRdm = null;
107 this.topConnXpdrXpdrPhtn = null;
108 this.topConnXpdrXpdrOdu = null;
112 public void onServicePathRpcResult(ServicePathRpcResult notification) {
113 if (compareServicePathRpcResult(notification)) {
114 LOG.warn("ServicePathRpcResult already wired !");
117 servicePathRpcResult = notification;
118 switch (servicePathRpcResult.getNotificationType().getIntValue()) {
119 /* path-computation-request. */
121 onPathComputationResult(notification);
123 /* cancel-resource-reserve. */
125 onCancelResourceResult(notification.getServiceName());
133 * Process path computation request result.
134 * @param notification the result notification.
136 private void onPathComputationResult(ServicePathRpcResult notification) {
137 this.connectionFullMap.clear();
138 LOG.info("PCE '{}' Notification received : {}",servicePathRpcResult.getNotificationType().getName(),
140 if (servicePathRpcResult.getStatus() == RpcStatusEx.Failed) {
141 LOG.error("PCE path computation failed !");
143 } else if (servicePathRpcResult.getStatus() == RpcStatusEx.Pending) {
144 LOG.warn("PCE path computation returned a Penging RpcStatusEx code!");
146 } else if (servicePathRpcResult.getStatus() != RpcStatusEx.Successful) {
147 LOG.error("PCE path computation returned an unknown RpcStatusEx code!");
151 LOG.info("PCE calculation done OK !");
152 if (servicePathRpcResult.getPathDescription() == null) {
153 LOG.error("'PathDescription' parameter is null ");
156 PathDescription pathDescription = new PathDescriptionBuilder()
157 .setAToZDirection(servicePathRpcResult.getPathDescription().getAToZDirection())
158 .setZToADirection(servicePathRpcResult.getPathDescription().getZToADirection())
160 LOG.info("PathDescription for TAPI gets : {}", pathDescription);
162 LOG.error("Input is null !");
165 // TODO: check kind of service: based on the device Id of the input,
166 // verify the type of XPDR and the capacity and determine if it is an OTN service or pure WDM service
167 // Create connections and ceps for the connectivity service.
168 // Connections must be with a locked stated. As the renderer hasnt implemented yet the oc's
169 Map<ConnectionKey, Connection> connectionMap = createConnectionsAndCepsForService(pathDescription,
170 input.getConnectivityConstraint().getServiceLayer());
171 // add connections to connection context and to connectivity context
172 updateConnectionContextWithConn(this.connectionFullMap, connectionMap, serviceUuid);
175 private Map<ConnectionKey, Connection> createConnectionsAndCepsForService(PathDescription pathDescription,
176 LayerProtocolName serviceProtName) {
177 Map<ConnectionKey, Connection> connectionServMap = new HashMap<>();
178 // build lists with ROADM nodes, XPDR/MUX/SWITCH nodes, ROADM DEG TTPs, ROADM SRG TTPs, XPDR CLIENT TTPs
179 // and XPDR NETWORK TTPs (if any). From the path description. This will help to build the uuid of the CEPs
180 // and the connections
182 List<String> xpdrClientTplist = new ArrayList<>();
183 List<String> xpdrNetworkTplist = new ArrayList<>();
184 List<String> rdmAddDropTplist = new ArrayList<>();
185 List<String> rdmDegTplist = new ArrayList<>();
186 List<String> rdmNodelist = new ArrayList<>();
187 List<String> xpdrNodelist = new ArrayList<>();
188 for (AToZ elem:pathDescription.getAToZDirection().getAToZ().values().stream()
189 .sorted((Comparator.comparing(atoz -> Integer.valueOf(atoz.getId())))).collect(Collectors.toList())) {
190 resourceType = elem.getResource().getResource().implementedInterface().getSimpleName();
191 switch (resourceType) {
192 case TapiStringConstants.TP:
193 TerminationPoint tp = (TerminationPoint) elem.getResource().getResource();
194 String tpID = tp.getTpId();
196 if (tpID.contains("CLIENT")) {
197 tpNode = tp.getTpNodeId();
198 if (!xpdrClientTplist.contains(String.join("+", tpNode, tpID))) {
199 xpdrClientTplist.add(String.join("+", tpNode, tpID));
202 if (tpID.contains("NETWORK")) {
203 tpNode = tp.getTpNodeId();
204 if (!xpdrNetworkTplist.contains(String.join("+", tpNode, tpID))) {
205 xpdrNetworkTplist.add(String.join("+", tpNode, tpID));
208 if (tpID.contains("PP")) {
209 tpNode = getIdBasedOnModelVersion(tp.getTpNodeId());
210 LOG.info("ROADM Node of tp = {}", tpNode);
211 if (!rdmAddDropTplist.contains(String.join("+", tpNode, tpID))) {
212 rdmAddDropTplist.add(String.join("+", tpNode, tpID));
215 if (tpID.contains("TTP")) {
216 tpNode = getIdBasedOnModelVersion(tp.getTpNodeId());
217 LOG.info("ROADM Node of tp = {}", tpNode);
218 if (!rdmDegTplist.contains(String.join("+", tpNode, tpID))) {
219 rdmDegTplist.add(String.join("+", tpNode, tpID));
223 case TapiStringConstants.NODE:
224 Node node = (Node) elem.getResource().getResource();
225 String nodeId = node.getNodeId();
226 if (nodeId.contains("XPDR") || nodeId.contains("SPDR") || nodeId.contains("MXPDR")) {
227 LOG.info("Node id = {}", nodeId);
228 if (!xpdrNodelist.contains(nodeId)) {
229 xpdrNodelist.add(nodeId); // should contain only 2
232 if (nodeId.contains("ROADM")) {
233 nodeId = getIdBasedOnModelVersion(nodeId);
234 LOG.info("Node id = {}", nodeId);
235 if (!rdmNodelist.contains(nodeId)) {
236 rdmNodelist.add(nodeId);
241 LOG.warn("Resource is a {}", resourceType);
244 LOG.info("ROADM node list = {}", rdmNodelist.toString());
245 LOG.info("ROADM degree list = {}", rdmDegTplist.toString());
246 LOG.info("ROADM addrop list = {}", rdmAddDropTplist.toString());
247 LOG.info("XPDR node list = {}", xpdrNodelist.toString());
248 LOG.info("XPDR network list = {}", xpdrNetworkTplist.toString());
249 LOG.info("XPDR client list = {}", xpdrClientTplist.toString());
250 // TODO -> for 10GB eth and ODU services there are no ROADMs in path description as they use the OTU link,
251 // but for 100GB eth all is created at once. Check if the roadm list is empty to determine whether we need
252 // to trigger all the steps or not
253 String edgeRoadm1 = "";
254 String edgeRoadm2 = "";
255 if (!rdmNodelist.isEmpty()) {
256 edgeRoadm1 = rdmNodelist.get(0);
257 edgeRoadm2 = rdmNodelist.get(rdmNodelist.size() - 1);
258 LOG.info("edgeRoadm1 = {}", edgeRoadm1);
259 LOG.info("edgeRoadm2 = {}", edgeRoadm2);
261 // create corresponding CEPs and Connections. Connections should be added to the corresponding context
262 // CEPs must be included in the topology context as an augmentation for each ONEP!!
263 // TODO -> Maybe we dont need to create the connections and ceps if the previous service doesnt exist??
264 // As mentioned above, for 100GbE service creation there are ROADMs in the path description.
265 // What are the configurations needed here? No OTU, ODU... what kind of cross connections is needed?
266 // this needs to be changed
268 // TODO: OpenROADM getNodeType from the NamesList to verify what needs to be created
269 OpenroadmNodeType openroadmNodeType = getOpenRoadmNodeType(xpdrNodelist);
270 switch (serviceProtName) {
272 // Identify number of ROADMs
273 // - XC Connection between MC CEPs mapped from MC NEPs (within a roadm)
274 // - XC Connection between OTSiMC CEPs mapped from OTSiMC NEPs (within a roadm)
275 // - Top Connection MC betwwen MC CEPs of different roadms
276 // - Top Connection OTSiMC betwwen OTSiMC CEPs of extreme roadms
277 connectionServMap.putAll(createRoadmCepsAndConnections(rdmAddDropTplist, rdmDegTplist, rdmNodelist,
278 edgeRoadm1, edgeRoadm2));
279 if (!pathDescription.getAToZDirection().getAToZ().values().stream().findFirst().get().getId()
280 .contains("ROADM")) {
281 // - XC Connection OTSi betwwen iOTSi y eOTSi of xpdr
282 // - Top connection OTSi between network ports of xpdrs in the Photonic media layer -> i_OTSi
283 connectionServMap.putAll(createXpdrCepsAndConnectionsPht(xpdrNetworkTplist, xpdrNodelist));
284 this.topConnRdmRdm = null;
288 // TODO: verify if this is correct
289 LOG.info("OTN ODU service");
290 // - XC Connection OTSi between iODU and eODU of xpdr
291 // - Top connection in the ODU layer, between xpdr iODU ports
292 if (openroadmNodeType.equals(OpenroadmNodeType.MUXPDR)) {
293 connectionServMap.putAll(createXpdrCepsAndConnectionsOdu(xpdrNetworkTplist, xpdrNodelist));
294 this.topConnXpdrXpdrPhtn = null;
298 LOG.info("WDM service");
299 if (openroadmNodeType.equals(OpenroadmNodeType.TPDR)) {
300 // TODO: WDM service. Only och/otu4 needed and then directly DSR top connection.
301 // Need to find the associated client ports of the network port
302 // - Same as for PHOTONIC MEDIA service
303 // - Do we nedd cross connection in the ODU layer??
304 // - Top connection DSR between client ports of the transponder
305 connectionServMap.putAll(createRoadmCepsAndConnections(rdmAddDropTplist, rdmDegTplist, rdmNodelist,
306 edgeRoadm1, edgeRoadm2));
307 connectionServMap.putAll(createXpdrCepsAndConnectionsPht(xpdrNetworkTplist, xpdrNodelist));
308 this.topConnRdmRdm = null;
309 xpdrClientTplist = getAssociatedClientsPort(xpdrNetworkTplist);
310 LOG.info("Associated client ports = {}", xpdrClientTplist);
311 connectionServMap.putAll(createXpdrCepsAndConnectionsEth(xpdrClientTplist, xpdrNodelist,
313 this.topConnXpdrXpdrPhtn = null;
317 LOG.info("OTN XGE/ODUe service");
318 // - XC connection between iODU and eODU
319 // - Top connection between eODU ports
320 // - Top connection between DSR ports
321 if (openroadmNodeType.equals(OpenroadmNodeType.SWITCH)) {
322 // TODO: We create both ODU and DSR because there is no ODU service creation for the switch
323 // - XC Connection OTSi betwwen iODU and eODU of xpdr
324 // - Top connection in the ODU layer, between xpdr eODU ports (?)
325 connectionServMap.putAll(createXpdrCepsAndConnectionsDsr(xpdrClientTplist, xpdrNetworkTplist,
327 this.topConnXpdrXpdrPhtn = null;
329 if (openroadmNodeType.equals(OpenroadmNodeType.MUXPDR)) {
330 // TODO: OTN service but mux has 3 steps at rendering. Verify that things exist
331 connectionServMap.putAll(createXpdrCepsAndConnectionsDsr(xpdrClientTplist, xpdrNetworkTplist,
333 this.topConnXpdrXpdrOdu = null;
337 LOG.error("Service type format {} not supported", serviceProtName.getName());
339 return connectionServMap;
343 * Process cancel resource result.
344 * @param serviceName Service name to build uuid.
346 private void onCancelResourceResult(String serviceName) {
347 if (servicePathRpcResult.getStatus() == RpcStatusEx.Failed) {
348 LOG.info("PCE cancel resource failed !");
350 } else if (servicePathRpcResult.getStatus() == RpcStatusEx.Pending) {
351 LOG.warn("PCE cancel returned a Penging RpcStatusEx code!");
353 } else if (servicePathRpcResult.getStatus() != RpcStatusEx.Successful) {
354 LOG.error("PCE cancel returned an unknown RpcStatusEx code!");
357 LOG.info("PCE cancel resource done OK !");
358 Uuid suuid = new Uuid(UUID.nameUUIDFromBytes(serviceName.getBytes(Charset.forName("UTF-8")))
360 // get connections of connectivity service and remove them from tapi context and then remove
361 // service from context. The CEPs are maintained as they could be reused by another service
362 ConnectivityService connService = getConnectivityService(suuid);
363 if (connService == null) {
364 LOG.error("Service doesnt exist in tapi context");
367 for (Connection connection:connService.getConnection().values()) {
368 deleteConnection(connection.getConnectionUuid());
370 deleteConnectivityService(suuid);
374 value = "ES_COMPARING_STRINGS_WITH_EQ",
375 justification = "false positives, not strings but real object references comparisons")
376 private Boolean compareServicePathRpcResult(ServicePathRpcResult notification) {
377 if (servicePathRpcResult == null) {
380 if (servicePathRpcResult.getNotificationType() != notification.getNotificationType()) {
383 if (servicePathRpcResult.getServiceName() != notification.getServiceName()) {
386 if (servicePathRpcResult.getStatus() != notification.getStatus()) {
389 if (servicePathRpcResult.getStatusMessage() != notification.getStatusMessage()) {
395 private Map<ConnectionKey, Connection> createXpdrCepsAndConnectionsEth(List<String> xpdrClientTplist,
396 List<String> xpdrNodelist,
397 Map<ConnectionKey, Connection> lowerConn) {
398 // TODO: do we need to create cross connection between iODU and eODU??
399 // add the lower connections of the previous steps for this kind of service
400 Map<LowerConnectionKey, LowerConnection> xcMap = new HashMap<>();
401 for (Connection lowConn: lowerConn.values()) {
402 LowerConnection conn = new LowerConnectionBuilder().setConnectionUuid(lowConn.getConnectionUuid()).build();
403 xcMap.put(conn.key(), conn);
405 Map<ConnectionKey, Connection> connServMap = new HashMap<>();
406 Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey,
407 ConnectionEndPoint> cepMapDsr = new HashMap<>();
408 // Create 1 cep per Xpdr in the CLIENT
409 // 1 top connection DSR between the CLIENT xpdrs
410 for (String xpdr:xpdrNodelist) {
411 LOG.info("Creating ceps and xc for xpdr {}", xpdr);
412 String spcXpdrClient = xpdrClientTplist.stream().filter(netp -> netp.contains(xpdr)).findFirst().get();
414 ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR,
415 LayerProtocolName.DSR);
416 putXpdrCepInTopologyContext(xpdr, spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR, netCep1);
418 cepMapDsr.put(netCep1.key(), netCep1);
420 String spcXpdr1 = xpdrClientTplist.stream().filter(adp -> adp.contains(xpdrNodelist
421 .get(0))).findFirst().get();
422 String spcXpdr2 = xpdrClientTplist.stream().filter(adp -> adp.contains(xpdrNodelist
423 .get(xpdrNodelist.size() - 1))).findFirst().get();
425 // DSR top connection between edge xpdr CLIENT DSR
426 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
427 connectionDsr = createTopConnection(spcXpdr1, spcXpdr2, cepMapDsr, TapiStringConstants.DSR,
428 LayerProtocolName.DSR, xcMap, this.topConnXpdrXpdrPhtn);
429 this.connectionFullMap.put(connectionDsr.key(), connectionDsr);
431 // DSR top connection that will be added to the service object
432 Connection conn1 = new ConnectionBuilder().setConnectionUuid(connectionDsr.getUuid()).build();
433 connServMap.put(conn1.key(), conn1);
438 private Map<ConnectionKey,Connection> createXpdrCepsAndConnectionsDsr(List<String> xpdrClientTplist,
439 List<String> xpdrNetworkTplist,
440 List<String> xpdrNodelist) {
441 Map<ConnectionKey, Connection> connServMap = new HashMap<>();
442 Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey,
443 ConnectionEndPoint> cepMapDsr = new HashMap<>();
444 Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey,
445 ConnectionEndPoint> cepMapOdu = new HashMap<>();
446 // TODO: when upgrading the models to 2.1.3, get the connection inclusion because those connections will
447 // be added to the lower connection of a top connection
448 Map<LowerConnectionKey, LowerConnection> xcMap = new HashMap<>();
450 // Create 1 cep per Xpdr in the CLIENT, 1 cep per Xpdr eODU, 1 XC between eODU and iODE,
451 // 1 top connection between eODU and a top connection DSR between the CLIENT xpdrs
452 for (String xpdr:xpdrNodelist) {
453 LOG.info("Creating ceps and xc for xpdr {}", xpdr);
454 String spcXpdrClient = xpdrClientTplist.stream().filter(netp -> netp.contains(xpdr)).findFirst().get();
456 ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR,
457 LayerProtocolName.DSR);
458 putXpdrCepInTopologyContext(xpdr, spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR, netCep1);
460 ConnectionEndPoint netCep2 = createCepXpdr(spcXpdrClient, TapiStringConstants.E_ODU,
461 TapiStringConstants.DSR, LayerProtocolName.ODU);
462 putXpdrCepInTopologyContext(xpdr, spcXpdrClient, TapiStringConstants.E_ODU, TapiStringConstants.DSR,
465 String spcXpdrNetwork = getAssociatedNetworkPort(spcXpdrClient, xpdrNetworkTplist);
466 ConnectionEndPoint netCep3 = getAssociatediODUCep(spcXpdrNetwork);
468 cepMapDsr.put(netCep1.key(), netCep1);
469 cepMapOdu.put(netCep2.key(), netCep2);
470 // Create x connection between I_ODU and E_ODU within xpdr
471 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
472 connection = createXCBetweenCeps(netCep2, netCep3, spcXpdrClient, spcXpdrNetwork,
473 TapiStringConstants.ODU, LayerProtocolName.ODU);
474 this.connectionFullMap.put(connection.key(), connection);
476 // Create X connection that will be added to the service object
477 LowerConnection conn = new LowerConnectionBuilder().setConnectionUuid(connection.getUuid()).build();
478 xcMap.put(conn.key(), conn);
481 String spcXpdr1 = xpdrClientTplist.stream().filter(adp -> adp.contains(xpdrNodelist
482 .get(0))).findFirst().get();
483 String spcXpdr2 = xpdrClientTplist.stream().filter(adp -> adp.contains(xpdrNodelist
484 .get(xpdrNodelist.size() - 1))).findFirst().get();
486 // eODU top connection between edge xpdr CLIENT eODU
487 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
488 connectionOdu = createTopConnection(spcXpdr1, spcXpdr2, cepMapOdu, TapiStringConstants.E_ODU,
489 LayerProtocolName.ODU, xcMap, this.topConnXpdrXpdrOdu);
490 this.connectionFullMap.put(connectionOdu.key(), connectionOdu);
492 // ODU top connection that will be added to the service object and also lower connection
493 Connection conn = new ConnectionBuilder().setConnectionUuid(connectionOdu.getUuid()).build();
494 connServMap.put(conn.key(), conn);
495 LowerConnection lowerConn = new LowerConnectionBuilder().setConnectionUuid(connectionOdu.getUuid()).build();
496 xcMap.put(lowerConn.key(), lowerConn);
498 // DSR top connection between edge xpdr CLIENT DSR
499 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
500 connectionDsr = createTopConnection(spcXpdr1, spcXpdr2, cepMapDsr, TapiStringConstants.DSR,
501 LayerProtocolName.DSR, xcMap, this.topConnXpdrXpdrPhtn);
502 this.connectionFullMap.put(connectionDsr.key(), connectionDsr);
504 // DSR top connection that will be added to the service object
505 Connection conn1 = new ConnectionBuilder().setConnectionUuid(connectionDsr.getUuid()).build();
506 connServMap.put(conn1.key(), conn1);
511 private Map<ConnectionKey, Connection> createXpdrCepsAndConnectionsOdu(List<String> xpdrNetworkTplist,
512 List<String> xpdrNodelist) {
513 Map<ConnectionKey, Connection> connServMap = new HashMap<>();
514 Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey,
515 ConnectionEndPoint> cepMap = new HashMap<>();
516 // TODO: when upgrading the models to 2.1.3, get the connection inclusion because those connections will
517 // be added to the lower connection of a top connection
518 Map<LowerConnectionKey, LowerConnection> xcMap = new HashMap<>();
519 // Create 1 cep per Xpdr in the I_ODU and a top
520 // connection iODU between the xpdrs
521 for (String xpdr:xpdrNodelist) {
522 LOG.info("Creating ceps and xc for xpdr {}", xpdr);
523 String spcXpdrNetwork = xpdrNetworkTplist.stream().filter(netp -> netp.contains(xpdr)).findFirst().get();
525 ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrNetwork, TapiStringConstants.I_ODU,
526 TapiStringConstants.DSR, LayerProtocolName.ODU);
527 putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, TapiStringConstants.I_ODU, TapiStringConstants.DSR,
530 cepMap.put(netCep1.key(), netCep1);
533 // ODU top connection between edge xpdr i_ODU
534 String spcXpdr1 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist
535 .get(0))).findFirst().get();
536 String spcXpdr2 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist
537 .get(xpdrNodelist.size() - 1))).findFirst().get();
538 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
539 connection = createTopConnection(spcXpdr1, spcXpdr2, cepMap, TapiStringConstants.I_ODU,
540 LayerProtocolName.ODU, xcMap, this.topConnXpdrXpdrPhtn);
541 this.connectionFullMap.put(connection.key(), connection);
543 // ODU top connection that will be added to the service object
544 Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build();
545 connServMap.put(conn.key(), conn);
546 this.topConnXpdrXpdrOdu = conn;
551 private Map<ConnectionKey, Connection> createXpdrCepsAndConnectionsPht(List<String> xpdrNetworkTplist,
552 List<String> xpdrNodelist) {
553 Map<ConnectionKey, Connection> connServMap = new HashMap<>();
554 Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey,
555 ConnectionEndPoint> cepMap = new HashMap<>();
556 // TODO: when upgrading the models to 2.1.3, get the connection inclusion because those connections will
557 // be added to the lower connection of a top connection
558 Map<LowerConnectionKey, LowerConnection> xcMap = new HashMap<>();
560 // create ceps and xc connections within xpdr
561 for (String xpdr:xpdrNodelist) {
562 LOG.info("Creating ceps and xc for xpdr {}", xpdr);
563 String spcXpdrNetwork = xpdrNetworkTplist.stream().filter(netp -> netp.contains(xpdr)).findFirst().get();
564 // There should be 1 network tp per xpdr
565 // TODO photonic media model should be updated to have the corresponding CEPs. I will just create
566 // 3 different MC CEPs giving different IDs to show that they are different
567 // Create 3 CEPs for each xpdr otsi node and the corresponding cross connection matchin the NEPs
568 ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrNetwork, TapiStringConstants.PHTNC_MEDIA,
569 TapiStringConstants.OTSI, LayerProtocolName.PHOTONICMEDIA);
570 putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, TapiStringConstants.PHTNC_MEDIA, TapiStringConstants.OTSI,
572 ConnectionEndPoint netCep2 = createCepXpdr(spcXpdrNetwork, TapiStringConstants.E_OTSI,
573 TapiStringConstants.OTSI, LayerProtocolName.PHOTONICMEDIA);
574 putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, TapiStringConstants.E_OTSI, TapiStringConstants.OTSI,
576 ConnectionEndPoint netCep3 = createCepXpdr(spcXpdrNetwork, TapiStringConstants.I_OTSI,
577 TapiStringConstants.OTSI, LayerProtocolName.PHOTONICMEDIA);
578 putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, TapiStringConstants.I_OTSI, TapiStringConstants.OTSI,
580 cepMap.put(netCep1.key(), netCep1);
581 cepMap.put(netCep2.key(), netCep2);
582 cepMap.put(netCep3.key(), netCep3);
584 // Create x connection between I_OTSi and E_OTSi within xpdr
585 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
586 connection = createXCBetweenCeps(netCep2, netCep3, spcXpdrNetwork, spcXpdrNetwork,
587 TapiStringConstants.OTSI, LayerProtocolName.PHOTONICMEDIA);
588 this.connectionFullMap.put(connection.key(), connection);
590 // Create X connection that will be added to the service object
591 LowerConnection conn = new LowerConnectionBuilder().setConnectionUuid(connection.getUuid()).build();
592 xcMap.put(conn.key(), conn);
594 // OTSi top connection between edge I_OTSI Xpdr
595 String spcXpdr1 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist
596 .get(0))).findFirst().get();
597 String spcXpdr2 = xpdrNetworkTplist.stream().filter(adp -> adp.contains(xpdrNodelist
598 .get(xpdrNodelist.size() - 1))).findFirst().get();
599 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
600 connection = createTopConnection(spcXpdr1, spcXpdr2, cepMap, TapiStringConstants.I_OTSI,
601 LayerProtocolName.PHOTONICMEDIA, xcMap, this.topConnRdmRdm);
602 this.connectionFullMap.put(connection.key(), connection);
604 // OTSi top connection that will be added to the service object
605 Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build();
606 connServMap.put(conn.key(), conn);
607 this.topConnXpdrXpdrPhtn = conn;
611 private Map<ConnectionKey, Connection> createRoadmCepsAndConnections(List<String> rdmAddDropTplist,
612 List<String> rdmDegTplist,
613 List<String> rdmNodelist,
614 String edgeRoadm1, String edgeRoadm2) {
615 // TODO: will need to check if things exist already or not
616 Map<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey,
617 ConnectionEndPoint> cepMap = new HashMap<>();
618 // create ceps and x connections within roadm
619 Map<LowerConnectionKey, LowerConnection> xcLowerMap = new HashMap<>();
620 for (String roadm : rdmNodelist) {
621 LOG.info("Creating ceps and xc for roadm {}", roadm);
622 if (roadm.equals(edgeRoadm1) || roadm.equals(edgeRoadm2)) {
623 LOG.info("EDGE ROADM, cross connections needed between SRG and DEG");
624 String spcRdmAD = rdmAddDropTplist.stream().filter(adp -> adp.contains(roadm)).findFirst().get();
625 LOG.info("AD port of ROADm {} = {}", roadm, spcRdmAD);
626 // There should be only 1 AD and 1 DEG per roadm
627 // TODO photonic media model should be updated to have the corresponding CEPs. I will just create
628 // 3 different MC CEPs giving different IDs to show that they are different
629 // Create 3 CEPs for each AD and DEG and the corresponding cross connections, matching the NEPs
630 // created in the topology creation
631 // add CEPs to the topology to the corresponding ONEP
632 ConnectionEndPoint adCep1 = createCepRoadm(spcRdmAD, TapiStringConstants.PHTNC_MEDIA);
633 putRdmCepInTopologyContext(roadm, spcRdmAD, TapiStringConstants.PHTNC_MEDIA, adCep1);
634 ConnectionEndPoint adCep2 = createCepRoadm(spcRdmAD, TapiStringConstants.MC);
635 putRdmCepInTopologyContext(roadm, spcRdmAD, TapiStringConstants.MC, adCep2);
636 ConnectionEndPoint adCep3 = createCepRoadm(spcRdmAD, TapiStringConstants.OTSI_MC);
637 putRdmCepInTopologyContext(roadm, spcRdmAD, TapiStringConstants.OTSI_MC, adCep3);
638 cepMap.put(adCep1.key(), adCep1);
639 cepMap.put(adCep2.key(), adCep2);
640 cepMap.put(adCep3.key(), adCep3);
642 String spcRdmDEG = rdmDegTplist.stream().filter(adp -> adp.contains(roadm)).findFirst().get();
643 LOG.info("Degree port of ROADm {} = {}", roadm, spcRdmDEG);
645 ConnectionEndPoint degCep1 = createCepRoadm(spcRdmDEG, TapiStringConstants.PHTNC_MEDIA);
646 putRdmCepInTopologyContext(roadm, spcRdmDEG, TapiStringConstants.PHTNC_MEDIA, degCep1);
647 ConnectionEndPoint degCep2 = createCepRoadm(spcRdmDEG, TapiStringConstants.MC);
648 putRdmCepInTopologyContext(roadm, spcRdmDEG, TapiStringConstants.MC, degCep2);
649 ConnectionEndPoint degCep3 = createCepRoadm(spcRdmDEG, TapiStringConstants.OTSI_MC);
650 putRdmCepInTopologyContext(roadm, spcRdmDEG, TapiStringConstants.OTSI_MC, degCep3);
651 cepMap.put(degCep1.key(), degCep1);
652 cepMap.put(degCep2.key(), degCep2);
653 cepMap.put(degCep3.key(), degCep3);
655 LOG.info("Going to create cross connections for ROADM {}", roadm);
656 // Create X connections between MC and OTSi_MC for full map
657 org.opendaylight.yang.gen.v1.urn
658 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection connection1
659 = createXCBetweenCeps(adCep2, degCep2, spcRdmAD, spcRdmDEG, TapiStringConstants.MC,
660 LayerProtocolName.PHOTONICMEDIA);
661 LOG.info("Cross connection 1 created = {}", connection1.toString());
662 org.opendaylight.yang.gen.v1.urn
663 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection connection2
664 = createXCBetweenCeps(adCep3, degCep3, spcRdmAD, spcRdmDEG, TapiStringConstants.OTSI_MC,
665 LayerProtocolName.PHOTONICMEDIA);
666 LOG.info("Cross connection 2 created = {}", connection2.toString());
667 this.connectionFullMap.put(connection1.key(), connection1);
668 this.connectionFullMap.put(connection2.key(), connection2);
670 // Create X connections that will be added to the service object
671 LowerConnection conn1 = new LowerConnectionBuilder().setConnectionUuid(connection1.getUuid()).build();
672 LowerConnection conn2 = new LowerConnectionBuilder().setConnectionUuid(connection2.getUuid()).build();
674 xcLowerMap.put(conn1.key(), conn1);
675 xcLowerMap.put(conn2.key(), conn2);
677 LOG.info("MIDDLE ROADM, cross connections needed between DEG and DEG");
678 String spcRdmDEG1 = rdmDegTplist.stream().filter(adp -> adp.contains(roadm)).findFirst().get();
679 LOG.info("Degree 1 port of ROADm {} = {}", roadm, spcRdmDEG1);
681 ConnectionEndPoint deg1Cep1 = createCepRoadm(spcRdmDEG1, TapiStringConstants.PHTNC_MEDIA);
682 putRdmCepInTopologyContext(roadm, spcRdmDEG1, TapiStringConstants.PHTNC_MEDIA, deg1Cep1);
683 ConnectionEndPoint deg1Cep2 = createCepRoadm(spcRdmDEG1, TapiStringConstants.MC);
684 putRdmCepInTopologyContext(roadm, spcRdmDEG1, TapiStringConstants.MC, deg1Cep2);
685 ConnectionEndPoint deg1Cep3 = createCepRoadm(spcRdmDEG1, TapiStringConstants.OTSI_MC);
686 putRdmCepInTopologyContext(roadm, spcRdmDEG1, TapiStringConstants.OTSI_MC, deg1Cep3);
687 cepMap.put(deg1Cep1.key(), deg1Cep1);
688 cepMap.put(deg1Cep2.key(), deg1Cep2);
689 cepMap.put(deg1Cep3.key(), deg1Cep3);
691 String spcRdmDEG2 = rdmDegTplist.stream().filter(adp -> adp.contains(roadm)).skip(1).findFirst().get();
692 LOG.info("Degree 2 port of ROADm {} = {}", roadm, spcRdmDEG2);
694 ConnectionEndPoint deg2Cep1 = createCepRoadm(spcRdmDEG2, TapiStringConstants.PHTNC_MEDIA);
695 putRdmCepInTopologyContext(roadm, spcRdmDEG2, TapiStringConstants.PHTNC_MEDIA, deg2Cep1);
696 ConnectionEndPoint deg2Cep2 = createCepRoadm(spcRdmDEG2, TapiStringConstants.MC);
697 putRdmCepInTopologyContext(roadm, spcRdmDEG2, TapiStringConstants.MC, deg2Cep2);
698 ConnectionEndPoint deg2Cep3 = createCepRoadm(spcRdmDEG2, TapiStringConstants.OTSI_MC);
699 putRdmCepInTopologyContext(roadm, spcRdmDEG2, TapiStringConstants.OTSI_MC, deg2Cep3);
700 cepMap.put(deg2Cep1.key(), deg2Cep1);
701 cepMap.put(deg2Cep2.key(), deg2Cep2);
702 cepMap.put(deg2Cep3.key(), deg2Cep3);
704 LOG.info("Going to create cross connections for ROADM {}", roadm);
705 // Create X connections between MC and OTSi_MC for full map
706 org.opendaylight.yang.gen.v1.urn
707 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection connection1
708 = createXCBetweenCeps(deg1Cep2, deg2Cep2, spcRdmDEG1, spcRdmDEG2,
709 TapiStringConstants.MC, LayerProtocolName.PHOTONICMEDIA);
710 LOG.info("Cross connection 1 created = {}", connection1.toString());
711 org.opendaylight.yang.gen.v1.urn
712 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection connection2
713 = createXCBetweenCeps(deg1Cep3, deg2Cep3, spcRdmDEG1, spcRdmDEG2,
714 TapiStringConstants.OTSI_MC, LayerProtocolName.PHOTONICMEDIA);
715 LOG.info("Cross connection 2 created = {}", connection2.toString());
716 this.connectionFullMap.put(connection1.key(), connection1);
717 this.connectionFullMap.put(connection2.key(), connection2);
719 // Create X connections that will be added to the service object
720 LowerConnection conn1 = new LowerConnectionBuilder().setConnectionUuid(connection1.getUuid()).build();
721 LowerConnection conn2 = new LowerConnectionBuilder().setConnectionUuid(connection2.getUuid()).build();
723 xcLowerMap.put(conn1.key(), conn1);
724 xcLowerMap.put(conn2.key(), conn2);
727 LOG.info("Going to create top connections between roadms");
728 String spcRdmAD1 = rdmAddDropTplist.stream().filter(adp -> adp.contains(edgeRoadm1)).findFirst().get();
729 String spcRdmAD2 = rdmAddDropTplist.stream().filter(adp -> adp.contains(edgeRoadm2)).findFirst().get();
730 // MC top connection between edge roadms
731 LOG.info("Going to created top connection between MC");
732 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
733 connection = createTopConnection(spcRdmAD1, spcRdmAD2, cepMap, TapiStringConstants.MC,
734 LayerProtocolName.PHOTONICMEDIA, xcLowerMap, null);
735 this.connectionFullMap.put(connection.key(), connection);
736 LOG.info("Top connection created = {}", connection.toString());
738 Map<ConnectionKey, Connection> connServMap = new HashMap<>();
739 // OTSiMC top connections that will be added to the service object
740 Connection conn = new ConnectionBuilder().setConnectionUuid(connection.getUuid()).build();
741 connServMap.put(conn.key(), conn);
742 LowerConnection conn1 = new LowerConnectionBuilder().setConnectionUuid(connection.getUuid()).build();
743 Map<LowerConnectionKey, LowerConnection> topLowerMap = new HashMap<>();
744 topLowerMap.put(conn1.key(), conn1);
746 // OTSiMC top connection between edge roadms
747 LOG.info("Going to created top connection between OTSiMC");
748 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
749 connection1 = createTopConnection(spcRdmAD1, spcRdmAD2, cepMap, TapiStringConstants.OTSI_MC,
750 LayerProtocolName.PHOTONICMEDIA, topLowerMap, null);
751 this.connectionFullMap.put(connection1.key(), connection1);
752 LOG.info("Top connection created = {}", connection1.toString());
754 // OTSiMC top connections that will be added to the service object
755 Connection conn2 = new ConnectionBuilder().setConnectionUuid(connection1.getUuid()).build();
756 connServMap.put(conn2.key(), conn2);
757 this.topConnRdmRdm = conn2;
761 private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
762 createTopConnection(String tp1, String tp2,
763 Map<org.opendaylight.yang.gen.v1.urn
764 .onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey,
765 ConnectionEndPoint> cepMap, String qual, LayerProtocolName topPortocol,
766 Map<LowerConnectionKey, LowerConnection> xcMap, Connection additionalLowerConn) {
767 // find cep for each AD MC of roadm 1 and 2
768 LOG.info("Top connection name = {}", String.join("+", "TOP", tp1, tp2, qual));
769 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.ConnectionEndPoint adCep1 =
770 cepMap.get(new org.opendaylight.yang.gen.v1.urn
771 .onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey(
772 new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", tp1.split("\\+")[0],
773 qual, tp1.split("\\+")[1])).getBytes(Charset.forName("UTF-8")))
775 LOG.info("ADCEP1 = {}", adCep1.toString());
776 org.opendaylight.yang.gen.v1.urn
777 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cep1 =
778 new org.opendaylight.yang.gen.v1.urn
779 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder()
780 .setNodeEdgePointUuid(adCep1.getClientNodeEdgePoint()
781 .values().stream().findFirst().get().getNodeEdgePointUuid())
782 .setTopologyUuid(adCep1.getClientNodeEdgePoint()
783 .values().stream().findFirst().get().getTopologyUuid())
784 .setNodeUuid(adCep1.getClientNodeEdgePoint()
785 .values().stream().findFirst().get().getNodeUuid())
786 .setConnectionEndPointUuid(adCep1.getUuid())
788 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.ConnectionEndPoint adCep2 =
789 cepMap.get(new org.opendaylight.yang.gen.v1.urn
790 .onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey(
791 new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", tp2.split("\\+")[0],
792 qual, tp2.split("\\+")[1])).getBytes(Charset.forName("UTF-8")))
794 LOG.info("ADCEP2 = {}", adCep2.toString());
795 org.opendaylight.yang.gen.v1.urn
796 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cep2 =
797 new org.opendaylight.yang.gen.v1.urn
798 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder()
799 .setNodeEdgePointUuid(adCep2.getClientNodeEdgePoint()
800 .values().stream().findFirst().get().getNodeEdgePointUuid())
801 .setTopologyUuid(adCep2.getClientNodeEdgePoint()
802 .values().stream().findFirst().get().getTopologyUuid())
803 .setNodeUuid(adCep2.getClientNodeEdgePoint()
804 .values().stream().findFirst().get().getNodeUuid())
805 .setConnectionEndPointUuid(adCep1.getUuid())
807 Map<ConnectionEndPointKey, org.opendaylight.yang.gen.v1.urn
808 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint> ceps = new HashMap<>();
809 ceps.put(cep1.key(), cep1);
810 ceps.put(cep2.key(), cep2);
811 Name connName = new NameBuilder()
812 .setValueName("Connection name")
813 .setValue(String.join("+", "TOP", tp1, tp2, qual))
815 // TODO: lower connection, supported link.......
816 if (additionalLowerConn != null) {
817 xcMap.putIfAbsent(new LowerConnectionKey(additionalLowerConn.getConnectionUuid()),
818 new LowerConnectionBuilder().setConnectionUuid(additionalLowerConn.getConnectionUuid()).build());
820 return new org.opendaylight.yang.gen.v1.urn
821 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionBuilder()
822 .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "TOP", tp1, tp2, qual))
823 .getBytes(Charset.forName("UTF-8"))).toString()))
824 .setName(Map.of(connName.key(), connName))
825 .setConnectionEndPoint(ceps)
826 .setOperationalState(OperationalState.DISABLED)
827 .setLayerProtocolName(topPortocol)
828 .setLifecycleState(LifecycleState.POTENTIALAVAILABLE)
829 .setDirection(ForwardingDirection.BIDIRECTIONAL)
830 .setLowerConnection(xcMap)
834 private org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection
835 createXCBetweenCeps(ConnectionEndPoint cep1, ConnectionEndPoint cep2, String tp1, String tp2, String qual,
836 LayerProtocolName xcProtocol) {
837 LOG.info("Creation cross connection between: {} and {}", tp1, tp2);
838 LOG.info("Cross connection name = {}", String.join("+", "XC", tp1, tp2, qual));
839 LOG.info("CEP1 = {}", cep1.getClientNodeEdgePoint().toString());
840 LOG.info("CEP2 = {}", cep2.getClientNodeEdgePoint().toString());
841 org.opendaylight.yang.gen.v1.urn
842 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cepServ1 =
843 new org.opendaylight.yang.gen.v1.urn
844 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder()
845 .setNodeEdgePointUuid(cep1.getClientNodeEdgePoint()
846 .values().stream().findFirst().get().getNodeEdgePointUuid())
847 .setTopologyUuid(cep1.getClientNodeEdgePoint()
848 .values().stream().findFirst().get().getTopologyUuid())
849 .setNodeUuid(cep1.getClientNodeEdgePoint()
850 .values().stream().findFirst().get().getNodeUuid())
851 .setConnectionEndPointUuid(cep1.getUuid())
853 org.opendaylight.yang.gen.v1.urn
854 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint cepServ2 =
855 new org.opendaylight.yang.gen.v1.urn
856 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPointBuilder()
857 .setNodeEdgePointUuid(cep2.getClientNodeEdgePoint()
858 .values().stream().findFirst().get().getNodeEdgePointUuid())
859 .setTopologyUuid(cep2.getClientNodeEdgePoint()
860 .values().stream().findFirst().get().getTopologyUuid())
861 .setNodeUuid(cep2.getClientNodeEdgePoint()
862 .values().stream().findFirst().get().getNodeUuid())
863 .setConnectionEndPointUuid(cep2.getUuid())
865 Map<ConnectionEndPointKey, org.opendaylight.yang.gen.v1.urn
866 .onf.otcc.yang.tapi.connectivity.rev181210.connection.ConnectionEndPoint> ceps = new HashMap<>();
867 ceps.put(cepServ1.key(), cepServ1);
868 ceps.put(cepServ2.key(), cepServ2);
869 Name connName = new NameBuilder()
870 .setValueName("Connection name")
871 .setValue(String.join("+", "XC", tp1, tp2, qual))
873 // TODO: lower connection, supported link.......
874 return new org.opendaylight.yang.gen.v1.urn
875 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionBuilder()
876 .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "XC", tp1, tp2, qual))
877 .getBytes(Charset.forName("UTF-8"))).toString()))
878 .setName(Map.of(connName.key(), connName))
879 .setConnectionEndPoint(ceps)
880 .setOperationalState(OperationalState.ENABLED)
881 .setLayerProtocolName(xcProtocol)
882 .setLifecycleState(LifecycleState.INSTALLED)
883 .setDirection(ForwardingDirection.BIDIRECTIONAL)
887 private ConnectionEndPoint createCepRoadm(String id, String qualifier) {
888 LOG.info("NEP = {}", String.join("+", id.split("\\+")[0], qualifier, id.split("\\+")[1]));
889 Name cepName = new NameBuilder()
890 .setValueName("ConnectionEndPoint name")
891 .setValue(String.join("+", id.split("\\+")[0], qualifier,
894 ClientNodeEdgePoint cnep = new ClientNodeEdgePointBuilder()
895 .setNodeEdgePointUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", id.split("\\+")[0],
896 qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8")))
898 .setNodeUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+",id.split("\\+")[0],
899 "PHOTONIC_MEDIA")).getBytes(Charset.forName("UTF-8")))
901 .setTopologyUuid(new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
902 .getBytes(Charset.forName("UTF-8"))).toString()))
904 // TODO: add augmentation with the corresponding cep-spec (i.e. MC, OTSiMC...)
905 // TODO: add parent ONEP??
906 ConnectionEndPointBuilder cepBldr = new ConnectionEndPointBuilder()
907 .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", id.split("\\+")[0],
908 qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8")))
910 .setClientNodeEdgePoint(Map.of(cnep.key(), cnep))
911 .setName(Map.of(cepName.key(), cepName))
912 .setConnectionPortRole(PortRole.SYMMETRIC)
913 .setConnectionPortDirection(PortDirection.BIDIRECTIONAL)
914 .setOperationalState(OperationalState.ENABLED)
915 .setLifecycleState(LifecycleState.INSTALLED)
916 .setLayerProtocolName(LayerProtocolName.PHOTONICMEDIA);
917 return cepBldr.build();
920 private ConnectionEndPoint createCepXpdr(String id, String qualifier, String nodeLayer,
921 LayerProtocolName cepProtocol) {
922 Name cepName = new NameBuilder()
923 .setValueName("ConnectionEndPoint name")
924 .setValue(String.join("+", id.split("\\+")[0], qualifier,
927 ClientNodeEdgePoint cnep = new ClientNodeEdgePointBuilder()
928 .setNodeEdgePointUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", id.split("\\+")[0],
929 qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8")))
931 .setNodeUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+",id.split("\\+")[0],
932 nodeLayer)).getBytes(Charset.forName("UTF-8")))
934 .setTopologyUuid(new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
935 .getBytes(Charset.forName("UTF-8"))).toString()))
937 // TODO: add augmentation with the corresponding cep-spec (i.e. MC, OTSiMC...)
938 // TODO: add parent ONEP??
939 ConnectionEndPointBuilder cepBldr = new ConnectionEndPointBuilder()
940 .setUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP", id.split("\\+")[0],
941 qualifier, id.split("\\+")[1])).getBytes(Charset.forName("UTF-8")))
943 .setClientNodeEdgePoint(Map.of(cnep.key(), cnep))
944 .setName(Map.of(cepName.key(), cepName))
945 .setConnectionPortRole(PortRole.SYMMETRIC)
946 .setConnectionPortDirection(PortDirection.BIDIRECTIONAL)
947 .setOperationalState(OperationalState.ENABLED)
948 .setLifecycleState(LifecycleState.INSTALLED)
949 .setLayerProtocolName(cepProtocol);
950 return cepBldr.build();
953 private void putRdmCepInTopologyContext(String node, String spcRdmAD, String qual, ConnectionEndPoint cep) {
954 LOG.info("NEP id before Merge = {}", String.join("+", node, qual, spcRdmAD.split("\\+")[1]));
955 LOG.info("Node of NEP id before Merge = {}", String.join("+", node, TapiStringConstants.PHTNC_MEDIA));
956 // Give uuids so that it is easier to look for things: topology uuid, node uuid, nep uuid, cep
957 Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
958 .getBytes(Charset.forName("UTF-8"))).toString());
959 Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, TapiStringConstants.PHTNC_MEDIA)
960 .getBytes(Charset.forName("UTF-8"))).toString());
961 Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, qual, spcRdmAD.split("\\+")[1])
962 .getBytes(Charset.forName("UTF-8"))).toString());
963 updateTopologyWithCep(topoUuid, nodeUuid, nepUuid, cep);
966 private void putXpdrCepInTopologyContext(String node, String spcXpdrNet, String qual, String nodeLayer,
967 ConnectionEndPoint cep) {
968 // Give uuids so that it is easier to look for things: topology uuid, node uuid, nep uuid, cep
969 Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
970 .getBytes(Charset.forName("UTF-8"))).toString());
971 Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, nodeLayer)
972 .getBytes(Charset.forName("UTF-8"))).toString());
973 Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes(String.join("+", node, qual, spcXpdrNet.split("\\+")[1])
974 .getBytes(Charset.forName("UTF-8"))).toString());
975 updateTopologyWithCep(topoUuid, nodeUuid, nepUuid, cep);
978 public void updateTopologyWithCep(Uuid topoUuid, Uuid nodeUuid, Uuid nepUuid, ConnectionEndPoint cep) {
979 // TODO: verify this is correct. Should we identify the context IID with the context UUID??
980 InstanceIdentifier<OwnedNodeEdgePoint> onepIID = InstanceIdentifier.builder(Context.class)
981 .augmentation(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.Context1.class)
982 .child(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.context.TopologyContext.class)
983 .child(Topology.class, new TopologyKey(topoUuid))
984 .child(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node.class,
985 new NodeKey(nodeUuid))
986 .child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nepUuid))
989 Optional<OwnedNodeEdgePoint> optionalOnep = this.networkTransactionService.read(
990 LogicalDatastoreType.OPERATIONAL, onepIID).get();
991 if (!optionalOnep.isPresent()) {
992 LOG.error("ONEP is not present in datastore");
995 OwnedNodeEdgePoint onep = optionalOnep.get();
996 LOG.info("ONEP found = {}", onep.toString());
997 // TODO -> If cep exists -> skip merging to datasore
998 OwnedNodeEdgePoint1 onep1 = onep.augmentation(OwnedNodeEdgePoint1.class);
999 if (onep1 != null && onep1.getCepList() != null && onep1.getCepList().getConnectionEndPoint() != null) {
1000 if (onep1.getCepList().getConnectionEndPoint().containsKey(
1001 new org.opendaylight.yang.gen.v1
1002 .urn.onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey(cep.key()))) {
1003 LOG.info("CEP already in topology, skipping merge");
1008 CepList cepList = new CepListBuilder().setConnectionEndPoint(Map.of(cep.key(), cep)).build();
1009 OwnedNodeEdgePoint1 onep1Bldr = new OwnedNodeEdgePoint1Builder().setCepList(cepList).build();
1010 OwnedNodeEdgePoint newOnep = new OwnedNodeEdgePointBuilder(onep)
1011 .addAugmentation(onep1Bldr)
1013 LOG.info("New ONEP is {}", newOnep.toString());
1014 // merge in datastore
1015 this.networkTransactionService.merge(LogicalDatastoreType.OPERATIONAL, onepIID,
1017 this.networkTransactionService.commit().get();
1018 LOG.info("CEP added successfully.");
1019 } catch (InterruptedException | ExecutionException e) {
1020 LOG.error("Couldnt update cep in topology", e);
1024 private void updateConnectionContextWithConn(
1025 Map<org.opendaylight.yang.gen.v1.urn
1026 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionKey,
1027 org.opendaylight.yang.gen.v1.urn
1028 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection> connFullMap,
1029 Map<ConnectionKey, Connection> connMap, Uuid suuid) {
1030 // TODO: verify this is correct. Should we identify the context IID with the context UUID??
1032 ConnectivityService connServ = getConnectivityService(suuid);
1033 ConnectivityService updtConnServ = new ConnectivityServiceBuilder(connServ)
1034 .setConnection(connMap)
1037 // Perform the merge operation with the new conn service and the connection context updated
1038 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext
1039 connectivityContext = new ConnectivityContextBuilder()
1040 .setConnectivityService(Map.of(updtConnServ.key(), updtConnServ))
1041 .setConnection(connFullMap)
1043 InstanceIdentifier<org.opendaylight.yang.gen.v1.urn
1044 .onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext> connectivitycontextIID =
1045 InstanceIdentifier.builder(Context.class).augmentation(Context1.class)
1046 .child(org.opendaylight.yang.gen.v1.urn
1047 .onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext.class)
1049 // merge in datastore
1050 this.networkTransactionService.merge(LogicalDatastoreType.OPERATIONAL, connectivitycontextIID,
1051 connectivityContext);
1052 this.networkTransactionService.commit().get();
1053 LOG.info("TAPI connectivity merged successfully.");
1054 } catch (InterruptedException | ExecutionException e) {
1055 LOG.error("Failed to merge TAPI connectivity", e);
1059 private ConnectivityService getConnectivityService(Uuid suuid) {
1061 // First read connectivity service with service uuid and update info
1062 InstanceIdentifier<ConnectivityService> connectivityServIID =
1063 InstanceIdentifier.builder(Context.class).augmentation(Context1.class)
1064 .child(org.opendaylight.yang.gen.v1.urn
1065 .onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext.class)
1066 .child(ConnectivityService.class, new ConnectivityServiceKey(suuid))
1069 Optional<ConnectivityService> optConnServ =
1070 this.networkTransactionService.read(LogicalDatastoreType.OPERATIONAL, connectivityServIID).get();
1071 if (!optConnServ.isPresent()) {
1072 LOG.error("Connectivity service not found in tapi context");
1075 return optConnServ.get();
1076 } catch (InterruptedException | ExecutionException e) {
1077 LOG.error("Connectivity service not found in tapi context. Error:", e);
1082 private void deleteConnectivityService(Uuid suuid) {
1083 // First read connectivity service with service uuid and update info
1084 InstanceIdentifier<ConnectivityService> connectivityServIID =
1085 InstanceIdentifier.builder(Context.class).augmentation(Context1.class)
1086 .child(org.opendaylight.yang.gen.v1.urn
1087 .onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext.class)
1088 .child(ConnectivityService.class, new ConnectivityServiceKey(suuid))
1091 this.networkTransactionService.delete(LogicalDatastoreType.OPERATIONAL, connectivityServIID);
1092 this.networkTransactionService.commit().get();
1093 } catch (InterruptedException | ExecutionException e) {
1094 LOG.error("Failed to delete TAPI connectivity service", e);
1098 private void deleteConnection(Uuid connectionUuid) {
1099 // First read connectivity service with service uuid and update info
1100 InstanceIdentifier<org.opendaylight.yang.gen.v1
1101 .urn.onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection> connectionIID =
1102 InstanceIdentifier.builder(Context.class).augmentation(Context1.class)
1103 .child(org.opendaylight.yang.gen.v1.urn
1104 .onf.otcc.yang.tapi.connectivity.rev181210.context.ConnectivityContext.class)
1105 .child(org.opendaylight.yang.gen.v1.urn
1106 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.Connection.class,
1107 new org.opendaylight.yang.gen.v1.urn
1108 .onf.otcc.yang.tapi.connectivity.rev181210.connectivity.context.ConnectionKey(
1112 this.networkTransactionService.delete(LogicalDatastoreType.OPERATIONAL, connectionIID);
1113 this.networkTransactionService.commit().get();
1114 } catch (InterruptedException | ExecutionException e) {
1115 LOG.error("Failed to delete TAPI connection", e);
1119 private String getIdBasedOnModelVersion(String nodeid) {
1120 return nodeid.matches("[A-Z]{5}-[A-Z0-9]{2}-.*")
1121 ? String.join("-", nodeid.split("-")[0], nodeid.split("-")[1]) : nodeid.split("-")[0];
1124 private ConnectionEndPoint getAssociatediODUCep(String spcXpdrNetwork) {
1125 Uuid topoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
1126 .getBytes(Charset.forName("UTF-8"))).toString());
1127 Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", spcXpdrNetwork.split("\\+")[0],
1128 TapiStringConstants.DSR).getBytes(Charset.forName("UTF-8")))).toString());
1129 Uuid nepUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", spcXpdrNetwork.split("\\+")[0],
1130 TapiStringConstants.I_ODU, spcXpdrNetwork.split("\\+")[1]).getBytes(Charset.forName("UTF-8"))))
1132 Uuid cepUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+", "CEP",
1133 spcXpdrNetwork.split("\\+")[0], TapiStringConstants.I_ODU, spcXpdrNetwork.split("\\+")[1]))
1134 .getBytes(Charset.forName("UTF-8"))).toString());
1135 InstanceIdentifier<OwnedNodeEdgePoint> nepIID = InstanceIdentifier.builder(Context.class)
1136 .augmentation(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.Context1.class)
1137 .child(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.context.TopologyContext.class)
1138 .child(Topology.class, new TopologyKey(topoUuid))
1139 .child(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node.class,
1140 new NodeKey(nodeUuid)).child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nepUuid)).build();
1142 Optional<OwnedNodeEdgePoint> optNode = this.networkTransactionService
1143 .read(LogicalDatastoreType.OPERATIONAL, nepIID).get();
1144 if (!optNode.isPresent()) {
1145 LOG.error("Node is not present in datastore");
1148 if (optNode.get().augmentation(OwnedNodeEdgePoint1.class) == null) {
1149 LOG.error("Node doesnt have ceps");
1152 return optNode.get().augmentation(OwnedNodeEdgePoint1.class).getCepList().getConnectionEndPoint()
1153 .get(new org.opendaylight.yang.gen.v1.urn
1154 .onf.otcc.yang.tapi.connectivity.rev181210.cep.list.ConnectionEndPointKey(cepUuid));
1155 } catch (InterruptedException | ExecutionException e) {
1156 LOG.error("Couldnt read node in topology", e);
1161 private String getAssociatedNetworkPort(String spcXpdrClient, List<String> xpdrNetworkTplist) {
1162 for (String networkPort:xpdrNetworkTplist) {
1163 if (networkPort.split("\\+")[0].equals(spcXpdrClient.split("\\+")[0])) {
1170 private OpenroadmNodeType getOpenRoadmNodeType(List<String> xpdrNodelist) {
1171 List<OpenroadmNodeType> openroadmNodeTypeList = new ArrayList<>();
1172 for (String xpdrNode:xpdrNodelist) {
1173 Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes((String.join("+",xpdrNode, TapiStringConstants.DSR))
1174 .getBytes(Charset.forName("UTF-8"))).toString());
1175 InstanceIdentifier<org.opendaylight.yang.gen.v1.urn
1176 .onf.otcc.yang.tapi.topology.rev181210.topology.Node> nodeIID
1177 = InstanceIdentifier.builder(Context.class).augmentation(org.opendaylight.yang.gen.v1.urn
1178 .onf.otcc.yang.tapi.topology.rev181210.Context1.class).child(TopologyContext.class)
1179 .child(Topology.class, new TopologyKey(this.tapiTopoUuid))
1180 .child(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node.class,
1181 new NodeKey(nodeUuid)).build();
1183 Optional<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node> optNode
1184 = this.networkTransactionService.read(LogicalDatastoreType.OPERATIONAL, nodeIID).get();
1185 if (!optNode.isPresent()) {
1188 OpenroadmNodeType openroadmNodeType = OpenroadmNodeType.forName(optNode.get().getName().get(
1189 new NameKey("Node Type")).getValue());
1190 if (!openroadmNodeTypeList.contains(openroadmNodeType)) {
1191 openroadmNodeTypeList.add(openroadmNodeType);
1193 } catch (InterruptedException | ExecutionException e) {
1194 LOG.error("Couldnt read node in topology", e);
1198 // TODO for now check that there is only one type, otherwise error
1199 if (openroadmNodeTypeList.size() != 1) {
1200 LOG.error("More than one xpdr type. List = {}", openroadmNodeTypeList);
1203 return openroadmNodeTypeList.get(0);
1206 private List<String> getAssociatedClientsPort(List<String> xpdrNetworkTplist) {
1207 List<String> clientPortList = new ArrayList<>();
1208 for (String networkPort:xpdrNetworkTplist) {
1209 String nodeId = String.join("-", networkPort.split("\\+")[0].split("-")[0],
1210 networkPort.split("\\+")[0].split("-")[1]);
1211 String tpId = networkPort.split("\\+")[1];
1212 InstanceIdentifier<Mapping> mapIID = InstanceIdentifier.builder(Network.class)
1213 .child(Nodes.class, new NodesKey(nodeId))
1214 .child(Mapping.class, new MappingKey(tpId)).build();
1216 Optional<Mapping> optMapping = this.networkTransactionService.read(LogicalDatastoreType.CONFIGURATION,
1218 if (!optMapping.isPresent()) {
1219 LOG.error("Couldnt find mapping for port {} of node {}", tpId, nodeId);
1221 Mapping mapping = optMapping.get();
1222 LOG.info("Mapping for node+port {}+{} = {}", nodeId, tpId, mapping);
1223 String key = String.join("+", String.join("-", nodeId, tpId.split("\\-")[0]),
1224 mapping.getConnectionMapLcp());
1225 LOG.info("Key to be added to list = {}", key);
1226 if (!clientPortList.contains(key)) {
1227 clientPortList.add(key);
1229 } catch (InterruptedException | ExecutionException e) {
1230 LOG.error("Couldnt read mapping from datastore", e);
1235 return clientPortList;
1238 public void setInput(CreateConnectivityServiceInput input) {
1242 public void setServiceUuid(Uuid serviceUuid) {
1243 this.serviceUuid = serviceUuid;