tapi/src/main/java/org/opendaylight/transportpce/tapi/listeners/TapiPceListenerImpl.java

   1 /*
   2  * Copyright © 2021 Nokia, Inc. and others.  All rights reserved.
   3  *
   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
   7  */
   8 package org.opendaylight.transportpce.tapi.listeners;
   9
  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;
  16 import java.util.Map;
  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.rev220922.Network;
  31 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.mapping.Mapping;
  32 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.mapping.MappingKey;
  33 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.network.Nodes;
  34 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev220922.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;
  82
  83 public class TapiPceListenerImpl implements TransportpcePceListener {
  84
  85     private static final Logger LOG = LoggerFactory.getLogger(TapiPceListenerImpl.class);
  86
  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;
 101
 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;
 109     }
 110
 111     @Override
 112     public void onServicePathRpcResult(ServicePathRpcResult notification) {
 113         if (compareServicePathRpcResult(notification)) {
 114             LOG.warn("ServicePathRpcResult already wired !");
 115             return;
 116         }
 117         servicePathRpcResult = notification;
 118         switch (servicePathRpcResult.getNotificationType().getIntValue()) {
 119             /* path-computation-request. */
 120             case 1:
 121                 onPathComputationResult(notification);
 122                 break;
 123             /* cancel-resource-reserve. */
 124             case 2:
 125                 onCancelResourceResult(notification.getServiceName());
 126                 break;
 127             default:
 128                 break;
 129         }
 130     }
 131
 132     /**
 133      * Process path computation request result.
 134      * @param notification the result notification.
 135      */
 136     private void onPathComputationResult(ServicePathRpcResult notification) {
 137         this.connectionFullMap.clear();
 138         LOG.info("PCE '{}' Notification received : {}",servicePathRpcResult.getNotificationType().getName(),
 139             notification);
 140         if (servicePathRpcResult.getStatus() == RpcStatusEx.Failed) {
 141             LOG.error("PCE path computation failed !");
 142             return;
 143         } else if (servicePathRpcResult.getStatus() == RpcStatusEx.Pending) {
 144             LOG.warn("PCE path computation returned a Penging RpcStatusEx code!");
 145             return;
 146         } else if (servicePathRpcResult.getStatus() != RpcStatusEx.Successful) {
 147             LOG.error("PCE path computation returned an unknown RpcStatusEx code!");
 148             return;
 149         }
 150
 151         LOG.info("PCE calculation done OK !");
 152         if (servicePathRpcResult.getPathDescription() == null) {
 153             LOG.error("'PathDescription' parameter is null ");
 154             return;
 155         }
 156         PathDescription pathDescription = new PathDescriptionBuilder()
 157             .setAToZDirection(servicePathRpcResult.getPathDescription().getAToZDirection())
 158             .setZToADirection(servicePathRpcResult.getPathDescription().getZToADirection())
 159             .build();
 160         LOG.info("PathDescription for TAPI gets : {}", pathDescription);
 161         if (input == null) {
 162             LOG.error("Input is null !");
 163             return;
 164         }
 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);
 173     }
 174
 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
 181         String resourceType;
 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();
 195                     String tpNode;
 196                     if (tpID.contains("CLIENT")) {
 197                         tpNode = tp.getTpNodeId();
 198                         if (!xpdrClientTplist.contains(String.join("+", tpNode, tpID))) {
 199                             xpdrClientTplist.add(String.join("+", tpNode, tpID));
 200                         }
 201                     }
 202                     if (tpID.contains("NETWORK")) {
 203                         tpNode = tp.getTpNodeId();
 204                         if (!xpdrNetworkTplist.contains(String.join("+", tpNode, tpID))) {
 205                             xpdrNetworkTplist.add(String.join("+", tpNode, tpID));
 206                         }
 207                     }
 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));
 213                         }
 214                     }
 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));
 220                         }
 221                     }
 222                     break;
 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
 230                         }
 231                     }
 232                     if (nodeId.contains("ROADM")) {
 233                         nodeId = getIdBasedOnModelVersion(nodeId);
 234                         LOG.info("Node id = {}", nodeId);
 235                         if (!rdmNodelist.contains(nodeId)) {
 236                             rdmNodelist.add(nodeId);
 237                         }
 238                     }
 239                     break;
 240                 default:
 241                     LOG.warn("Resource is a {}", resourceType);
 242             }
 243         }
 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);
 260         }
 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
 267
 268         // TODO: OpenROADM getNodeType from the NamesList to verify what needs to be created
 269         OpenroadmNodeType openroadmNodeType = getOpenRoadmNodeType(xpdrNodelist);
 270         switch (serviceProtName) {
 271             case PHOTONICMEDIA:
 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;
 285                 }
 286                 break;
 287             case ODU:
 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;
 295                 }
 296                 break;
 297             case ETH:
 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,
 312                         connectionServMap));
 313                     this.topConnXpdrXpdrPhtn = null;
 314                 }
 315                 break;
 316             case DSR:
 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,
 326                         xpdrNodelist));
 327                     this.topConnXpdrXpdrPhtn = null;
 328                 }
 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,
 332                         xpdrNodelist));
 333                     this.topConnXpdrXpdrOdu = null;
 334                 }
 335                 break;
 336             default:
 337                 LOG.error("Service type format {} not supported", serviceProtName.getName());
 338         }
 339         return connectionServMap;
 340     }
 341
 342     /**
 343      * Process cancel resource result.
 344      * @param serviceName Service name to build uuid.
 345      */
 346     private void onCancelResourceResult(String serviceName) {
 347         if (servicePathRpcResult.getStatus() == RpcStatusEx.Failed) {
 348             LOG.info("PCE cancel resource failed !");
 349             return;
 350         } else if (servicePathRpcResult.getStatus() == RpcStatusEx.Pending) {
 351             LOG.warn("PCE cancel returned a Penging RpcStatusEx code!");
 352             return;
 353         } else if (servicePathRpcResult.getStatus() != RpcStatusEx.Successful) {
 354             LOG.error("PCE cancel returned an unknown RpcStatusEx code!");
 355             return;
 356         }
 357         LOG.info("PCE cancel resource done OK !");
 358         Uuid suuid = new Uuid(UUID.nameUUIDFromBytes(serviceName.getBytes(Charset.forName("UTF-8")))
 359             .toString());
 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");
 365             return;
 366         }
 367         for (Connection connection:connService.getConnection().values()) {
 368             deleteConnection(connection.getConnectionUuid());
 369         }
 370         deleteConnectivityService(suuid);
 371     }
 372
 373     @SuppressFBWarnings(
 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) {
 378             return false;
 379         }
 380         if (servicePathRpcResult.getNotificationType() != notification.getNotificationType()) {
 381             return false;
 382         }
 383         if (servicePathRpcResult.getServiceName() != notification.getServiceName()) {
 384             return false;
 385         }
 386         if (servicePathRpcResult.getStatus() != notification.getStatus()) {
 387             return false;
 388         }
 389         if (servicePathRpcResult.getStatusMessage() != notification.getStatusMessage()) {
 390             return false;
 391         }
 392         return true;
 393     }
 394
 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);
 404         }
 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();
 413
 414             ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR,
 415                 LayerProtocolName.DSR);
 416             putXpdrCepInTopologyContext(xpdr, spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR, netCep1);
 417
 418             cepMapDsr.put(netCep1.key(), netCep1);
 419         }
 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();
 424
 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);
 430
 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);
 434
 435         return connServMap;
 436     }
 437
 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<>();
 449
 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();
 455
 456             ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR,
 457                 LayerProtocolName.DSR);
 458             putXpdrCepInTopologyContext(xpdr, spcXpdrClient, TapiStringConstants.DSR, TapiStringConstants.DSR, netCep1);
 459
 460             ConnectionEndPoint netCep2 = createCepXpdr(spcXpdrClient, TapiStringConstants.E_ODU,
 461                 TapiStringConstants.DSR, LayerProtocolName.ODU);
 462             putXpdrCepInTopologyContext(xpdr, spcXpdrClient, TapiStringConstants.E_ODU, TapiStringConstants.DSR,
 463                 netCep2);
 464
 465             String spcXpdrNetwork = getAssociatedNetworkPort(spcXpdrClient, xpdrNetworkTplist);
 466             ConnectionEndPoint netCep3 = getAssociatediODUCep(spcXpdrNetwork);
 467
 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);
 475
 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);
 479         }
 480
 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();
 485
 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);
 491
 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);
 497
 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);
 503
 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);
 507
 508         return connServMap;
 509     }
 510
 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();
 524
 525             ConnectionEndPoint netCep1 = createCepXpdr(spcXpdrNetwork, TapiStringConstants.I_ODU,
 526                 TapiStringConstants.DSR, LayerProtocolName.ODU);
 527             putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, TapiStringConstants.I_ODU, TapiStringConstants.DSR,
 528                 netCep1);
 529
 530             cepMap.put(netCep1.key(), netCep1);
 531         }
 532
 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);
 542
 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;
 547
 548         return connServMap;
 549     }
 550
 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<>();
 559
 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,
 571                 netCep1);
 572             ConnectionEndPoint netCep2 = createCepXpdr(spcXpdrNetwork, TapiStringConstants.E_OTSI,
 573                 TapiStringConstants.OTSI, LayerProtocolName.PHOTONICMEDIA);
 574             putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, TapiStringConstants.E_OTSI, TapiStringConstants.OTSI,
 575                 netCep2);
 576             ConnectionEndPoint netCep3 = createCepXpdr(spcXpdrNetwork, TapiStringConstants.I_OTSI,
 577                 TapiStringConstants.OTSI, LayerProtocolName.PHOTONICMEDIA);
 578             putXpdrCepInTopologyContext(xpdr, spcXpdrNetwork, TapiStringConstants.I_OTSI, TapiStringConstants.OTSI,
 579                 netCep3);
 580             cepMap.put(netCep1.key(), netCep1);
 581             cepMap.put(netCep2.key(), netCep2);
 582             cepMap.put(netCep3.key(), netCep3);
 583
 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);
 589
 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);
 593         }
 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);
 603
 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;
 608         return connServMap;
 609     }
 610
 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);
 641
 642                 String spcRdmDEG = rdmDegTplist.stream().filter(adp -> adp.contains(roadm)).findFirst().get();
 643                 LOG.info("Degree port of ROADm {} = {}", roadm, spcRdmDEG);
 644
 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);
 654
 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);
 669
 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();
 673
 674                 xcLowerMap.put(conn1.key(), conn1);
 675                 xcLowerMap.put(conn2.key(), conn2);
 676             } else {
 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);
 680
 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);
 690
 691                 String spcRdmDEG2 = rdmDegTplist.stream().filter(adp -> adp.contains(roadm)).skip(1).findFirst().get();
 692                 LOG.info("Degree 2 port of ROADm {} = {}", roadm, spcRdmDEG2);
 693
 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);
 703
 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);
 718
 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();
 722
 723                 xcLowerMap.put(conn1.key(), conn1);
 724                 xcLowerMap.put(conn2.key(), conn2);
 725             }
 726         }
 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());
 737
 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);
 745
 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());
 753
 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;
 758         return connServMap;
 759     }
 760
 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")))
 774                     .toString())));
 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())
 787                 .build();
 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")))
 793                     .toString())));
 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())
 806                 .build();
 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))
 814             .build();
 815         // TODO: lower connection, supported link.......
 816         if (additionalLowerConn != null) {
 817             xcMap.putIfAbsent(new LowerConnectionKey(additionalLowerConn.getConnectionUuid()),
 818                 new LowerConnectionBuilder().setConnectionUuid(additionalLowerConn.getConnectionUuid()).build());
 819         }
 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)
 831             .build();
 832     }
 833
 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())
 852                 .build();
 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())
 864                 .build();
 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))
 872             .build();
 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)
 884             .build();
 885     }
 886
 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,
 892                 id.split("\\+")[1]))
 893             .build();
 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")))
 897                 .toString()))
 898             .setNodeUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+",id.split("\\+")[0],
 899                     "PHOTONIC_MEDIA")).getBytes(Charset.forName("UTF-8")))
 900                 .toString()))
 901             .setTopologyUuid(new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
 902                 .getBytes(Charset.forName("UTF-8"))).toString()))
 903             .build();
 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")))
 909                 .toString()))
 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();
 918     }
 919
 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,
 925                 id.split("\\+")[1]))
 926             .build();
 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")))
 930                 .toString()))
 931             .setNodeUuid(new Uuid(UUID.nameUUIDFromBytes((String.join("+",id.split("\\+")[0],
 932                     nodeLayer)).getBytes(Charset.forName("UTF-8")))
 933                 .toString()))
 934             .setTopologyUuid(new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
 935                 .getBytes(Charset.forName("UTF-8"))).toString()))
 936             .build();
 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")))
 942                 .toString()))
 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();
 951     }
 952
 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);
 964     }
 965
 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);
 976     }
 977
 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))
 987             .build();
 988         try {
 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");
 993                 return;
 994             }
 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");
1004                     return;
1005                 }
1006             }
1007             // Updated ONEP
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)
1012                 .build();
1013             LOG.info("New ONEP is {}", newOnep.toString());
1014             // merge in datastore
1015             this.networkTransactionService.merge(LogicalDatastoreType.OPERATIONAL, onepIID,
1016                 newOnep);
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);
1021         }
1022     }
1023
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??
1031         try {
1032             ConnectivityService connServ = getConnectivityService(suuid);
1033             ConnectivityService updtConnServ = new ConnectivityServiceBuilder(connServ)
1034                 .setConnection(connMap)
1035                 .build();
1036
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)
1042                     .build();
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)
1048                     .build();
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);
1056         }
1057     }
1058
1059     private ConnectivityService getConnectivityService(Uuid suuid) {
1060         try {
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))
1067                     .build();
1068
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");
1073                 return null;
1074             }
1075             return optConnServ.get();
1076         } catch (InterruptedException | ExecutionException e) {
1077             LOG.error("Connectivity service not found in tapi context. Error:", e);
1078             return null;
1079         }
1080     }
1081
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))
1089                 .build();
1090         try {
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);
1095         }
1096     }
1097
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(
1109                         connectionUuid))
1110                 .build();
1111         try {
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);
1116         }
1117     }
1118
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];
1122     }
1123
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"))))
1131             .toString());
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();
1141         try {
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");
1146                 return null;
1147             }
1148             if (optNode.get().augmentation(OwnedNodeEdgePoint1.class) == null) {
1149                 LOG.error("Node doesnt have ceps");
1150                 return null;
1151             }
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);
1157             return null;
1158         }
1159     }
1160
1161     private String getAssociatedNetworkPort(String spcXpdrClient, List<String> xpdrNetworkTplist) {
1162         for (String networkPort:xpdrNetworkTplist) {
1163             if (networkPort.split("\\+")[0].equals(spcXpdrClient.split("\\+")[0])) {
1164                 return networkPort;
1165             }
1166         }
1167         return null;
1168     }
1169
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();
1182             try {
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()) {
1186                     return null;
1187                 }
1188                 OpenroadmNodeType openroadmNodeType = OpenroadmNodeType.forName(optNode.get().getName().get(
1189                     new NameKey("Node Type")).getValue());
1190                 if (!openroadmNodeTypeList.contains(openroadmNodeType)) {
1191                     openroadmNodeTypeList.add(openroadmNodeType);
1192                 }
1193             } catch (InterruptedException | ExecutionException e) {
1194                 LOG.error("Couldnt read node in topology", e);
1195                 return null;
1196             }
1197         }
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);
1201             return null;
1202         }
1203         return openroadmNodeTypeList.get(0);
1204     }
1205
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();
1215             try {
1216                 Optional<Mapping> optMapping = this.networkTransactionService.read(LogicalDatastoreType.CONFIGURATION,
1217                     mapIID).get();
1218                 if (!optMapping.isPresent()) {
1219                     LOG.error("Couldnt find mapping for port {} of node {}", tpId, nodeId);
1220                 }
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);
1228                 }
1229             } catch (InterruptedException | ExecutionException e) {
1230                 LOG.error("Couldnt read mapping from datastore", e);
1231                 return null;
1232             }
1233
1234         }
1235         return clientPortList;
1236     }
1237
1238     public void setInput(CreateConnectivityServiceInput input) {
1239         this.input = input;
1240     }
1241
1242     public void setServiceUuid(Uuid serviceUuid) {
1243         this.serviceUuid = serviceUuid;
1244     }
1245 }