tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TapiNetworkModelServiceImpl.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.topology;
   9
  10 import java.nio.charset.Charset;
  11 import java.nio.charset.StandardCharsets;
  12 import java.util.ArrayList;
  13 import java.util.Collection;
  14 import java.util.Collections;
  15 import java.util.Comparator;
  16 import java.util.HashMap;
  17 import java.util.HashSet;
  18 import java.util.List;
  19 import java.util.Map;
  20 import java.util.Objects;
  21 import java.util.Optional;
  22 import java.util.Set;
  23 import java.util.UUID;
  24 import java.util.concurrent.ExecutionException;
  25 import java.util.stream.Collectors;
  26 import org.opendaylight.mdsal.binding.api.NotificationPublishService;
  27 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  28 import org.opendaylight.transportpce.common.NetworkUtils;
  29 import org.opendaylight.transportpce.common.device.DeviceTransactionManager;
  30 import org.opendaylight.transportpce.common.fixedflex.GridConstant;
  31 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  32 import org.opendaylight.transportpce.tapi.R2RTapiLinkDiscovery;
  33 import org.opendaylight.transportpce.tapi.TapiStringConstants;
  34 import org.opendaylight.transportpce.tapi.utils.TapiLink;
  35 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev231221.mapping.Mapping;
  36 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.portmapping.rev231221.network.Nodes;
  37 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.TerminationPoint1;
  38 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  39 import org.opendaylight.yang.gen.v1.http.org.openroadm.device.types.rev191129.XpdrNodeTypes;
  40 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  41 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPools;
  42 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.OduSwitchingPoolsBuilder;
  43 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingList;
  44 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListBuilder;
  45 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.types.rev230526.xpdr.odu.switching.pools.odu.switching.pools.NonBlockingListKey;
  46 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmNodeType;
  47 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.xpdr.tp.supported.interfaces.SupportedInterfaceCapability;
  48 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.xpdr.tp.supported.interfaces.SupportedInterfaceCapabilityBuilder;
  49 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.xpdr.tp.supported.interfaces.SupportedInterfaceCapabilityKey;
  50 import org.opendaylight.yang.gen.v1.http.org.openroadm.port.types.rev230526.SupportedIfCapability;
  51 import org.opendaylight.yang.gen.v1.http.org.openroadm.switching.pool.types.rev191129.SwitchingPoolTypes;
  52 import org.opendaylight.yang.gen.v1.http.org.openroadm.xponder.rev230526.xpdr.mode.attributes.supported.operational.modes.OperationalModeKey;
  53 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NetworkId;
  54 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.Networks;
  55 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.NodeId;
  56 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.Network;
  57 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226.networks.NetworkKey;
  58 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.Node1;
  59 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.TpId;
  60 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226.networks.network.node.TerminationPoint;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.AdministrativeState;
  62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Context;
  63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.ContextBuilder;
  64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Direction;
  65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LayerProtocolName;
  66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LifecycleState;
  67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.OperationalState;
  68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.PortRole;
  69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Uuid;
  70 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.Name;
  71 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameBuilder;
  72 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameKey;
  73 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePoint;
  74 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePointBuilder;
  75 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePointKey;
  76 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.OwnedNodeEdgePoint1;
  77 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.OwnedNodeEdgePoint1Builder;
  78 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.cep.list.ConnectionEndPoint;
  79 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.cep.list.ConnectionEndPointBuilder;
  80 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.cep.list.ConnectionEndPointKey;
  81 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.context.Connection;
  82 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.context.ConnectionBuilder;
  83 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.context.ConnectionKey;
  84 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.context.ConnectivityService;
  85 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.context.ConnectivityServiceBuilder;
  86 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.context.ConnectivityServiceKey;
  87 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.service.EndPoint;
  88 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.connectivity.service.EndPointKey;
  89 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.context.ConnectivityContext;
  90 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.context.topology.context.topology.node.owned.node.edge.point.CepList;
  91 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.context.topology.context.topology.node.owned.node.edge.point.CepListBuilder;
  92 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev221121.NOTIFICATIONTYPEATTRIBUTEVALUECHANGE;
  93 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev221121.NotificationBuilder;
  94 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev221121.notification.ChangedAttributes;
  95 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev221121.notification.ChangedAttributesBuilder;
  96 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.notification.rev221121.notification.ChangedAttributesKey;
  97 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIERMC;
  98 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROMS;
  99 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTS;
 100 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTSiMC;
 101 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.context.topology.context.topology.node.owned.node.edge.point.PhotonicMediaNodeEdgePointSpec;
 102 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.Context1;
 103 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.FORWARDINGRULEMAYFORWARDACROSSGROUP;
 104 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.NodeEdgePointRef;
 105 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.RuleType;
 106 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.TOPOLOGYOBJECTTYPENODEEDGEPOINT;
 107 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.context.TopologyContext;
 108 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroup;
 109 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupBuilder;
 110 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupKey;
 111 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePoint;
 112 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointBuilder;
 113 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointKey;
 114 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.RiskParameterPac;
 115 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.RiskParameterPacBuilder;
 116 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.MappedServiceInterfacePoint;
 117 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstances;
 118 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstancesBuilder;
 119 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePoint;
 120 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointBuilder;
 121 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.NodeEdgePointKey;
 122 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.Rule;
 123 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleBuilder;
 124 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.rule.group.RuleKey;
 125 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristic;
 126 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristicBuilder;
 127 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Link;
 128 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkBuilder;
 129 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkKey;
 130 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node;
 131 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeBuilder;
 132 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeKey;
 133 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.context.Topology;
 134 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.context.TopologyBuilder;
 135 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.context.TopologyKey;
 136 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristic;
 137 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristicBuilder;
 138 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristic;
 139 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristicBuilder;
 140 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
 141 import org.opendaylight.yangtools.yang.common.Uint16;
 142 import org.opendaylight.yangtools.yang.common.Uint32;
 143 import org.opendaylight.yangtools.yang.common.Uint64;
 144 import org.osgi.service.component.annotations.Activate;
 145 import org.osgi.service.component.annotations.Component;
 146 import org.osgi.service.component.annotations.Reference;
 147 import org.slf4j.Logger;
 148 import org.slf4j.LoggerFactory;
 149
 150
 151 @Component
 152 public class TapiNetworkModelServiceImpl implements TapiNetworkModelService {
 153
 154     private static final Logger LOG = LoggerFactory.getLogger(TapiNetworkModelServiceImpl.class);
 155
 156     private final Uuid tapiTopoUuid = new Uuid(UUID.nameUUIDFromBytes(TapiStringConstants.T0_FULL_MULTILAYER
 157             .getBytes(StandardCharsets.UTF_8)).toString());
 158     private final NetworkTransactionService networkTransactionService;
 159     private final R2RTapiLinkDiscovery linkDiscovery;
 160     private final TapiLink tapiLink;
 161     private final ConvertORToTapiTopology tapiFactory;
 162     private String topologicalMode;
 163     private final ConvertORTopoToTapiFullTopo tapiFullFactory;
 164     private final NotificationPublishService notificationPublishService;
 165     private Map<ServiceInterfacePointKey, ServiceInterfacePoint> sipMap = new HashMap<>();
 166
 167     @Activate
 168     public TapiNetworkModelServiceImpl(@Reference NetworkTransactionService networkTransactionService,
 169             @Reference DeviceTransactionManager deviceTransactionManager,
 170             @Reference TapiLink tapiLink,
 171             @Reference final NotificationPublishService notificationPublishService) {
 172         this.networkTransactionService = networkTransactionService;
 173         this.linkDiscovery = new R2RTapiLinkDiscovery(networkTransactionService, deviceTransactionManager, tapiLink);
 174         this.notificationPublishService = notificationPublishService;
 175         this.tapiFactory = new ConvertORToTapiTopology(tapiTopoUuid);
 176         this.tapiLink = tapiLink;
 177         this.tapiFullFactory = new ConvertORTopoToTapiFullTopo(tapiTopoUuid, tapiLink);
 178         this.topologicalMode = tapiFullFactory.getTopologicalMode();
 179     }
 180
 181     @Override
 182     public void createTapiNode(String orNodeId, int orNodeVersion, Nodes node) {
 183         // TODO -> Implementation with PortMappingListener
 184         // check if port mapping exists or not...
 185         if (node.getMapping() == null) {
 186             LOG.warn("Could not generate port mapping for {} skipping network model creation", orNodeId);
 187             return;
 188         }
 189         this.sipMap.clear();
 190         LOG.info("Mapping of node {}: {}", orNodeId, node.getMapping().values());
 191         // check type of device, check version and create node mapping
 192         switch (node.getNodeInfo().getNodeType()) {
 193             case Rdm:
 194                 // ROADM device
 195                 // transform flat mapping list to per degree and per srg mapping lists
 196                 Map<String, List<Mapping>> mapDeg = new HashMap<>();
 197                 Map<String, List<Mapping>> mapSrg = new HashMap<>();
 198                 List<Mapping> mappingList = new ArrayList<>(node.nonnullMapping().values());
 199                 mappingList.sort(Comparator.comparing(Mapping::getLogicalConnectionPoint));
 200                 // populate degree and srg LCP map
 201                 for (String str : getRoadmNodelist(mappingList)) {
 202                     List<Mapping> interList = mappingList.stream()
 203                         .filter(x -> x.getLogicalConnectionPoint().contains(str))
 204                         .collect(Collectors.toList());
 205                     if (str.contains("DEG")) {
 206                         mapDeg.put(str, interList);
 207                     } else if (str.contains("SRG")) {
 208                         mapSrg.put(str, interList);
 209                     } else {
 210                         LOG.error("unknown element");
 211                     }
 212                 }
 213                 // Transform LCPs into ONEP
 214                 Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap =
 215                     new HashMap<>(transformSrgToOnep(orNodeId, mapSrg));
 216                 LOG.debug("CreateTapiNode NetworkModelServiceImpl, TopologicalMode = {}", topologicalMode);
 217                 LOG.debug("TAPINETWORKMODELSERVICEIMPL call transformSRGtoONEP (OrNodeId {} ", orNodeId);
 218                 LOG.debug("TAPINETWORKMODELSERVICEIMPL SRG OTSNode of retrieved OnepMap {} ",
 219                     onepMap.entrySet().stream()
 220                         .filter(e -> e.getValue().getSupportedCepLayerProtocolQualifierInstances()
 221                             .contains(
 222                                 new SupportedCepLayerProtocolQualifierInstancesBuilder()
 223                                     .setNumberOfCepInstances(Uint64.valueOf(1))
 224                                     .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
 225                                     .build()))
 226                         .collect(Collectors.toList()));
 227                 if (!topologicalMode.equals("Full")) {
 228                     // create tapi Node
 229                     Node roadmNode = createRoadmTapiNode("ROADMINFRA", onepMap);
 230                     mergeNodeinTopology(Map.of(roadmNode.key(), roadmNode));
 231                     mergeSipsinContext(this.sipMap);
 232                     // TODO add states corresponding to device config -> based on mapping.
 233                     //  This should be possible after Gilles work is merged
 234                     LOG.info("TAPI node for or node {} successfully merged", orNodeId);
 235                     break;
 236                 }
 237                 onepMap.putAll(transformDegToOnep(orNodeId, mapDeg));
 238                 LOG.debug("TAPINETWORKMODELSERVICEIMPL DEG+SRG OTSNode of retrieved OnepMap {} ",
 239                     onepMap.entrySet().stream()
 240                         .filter(e -> e.getValue().getSupportedCepLayerProtocolQualifierInstances()
 241                             .contains(
 242                                 new SupportedCepLayerProtocolQualifierInstancesBuilder()
 243                                     .setNumberOfCepInstances(Uint64.valueOf(1))
 244                                     .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
 245                                     .build()))
 246                         .collect(Collectors.toList()));
 247                 LOG.debug("TAPINETWORKMODELSERVICEIMPL DEG+SRG complete retrieved OnepMap {} ", onepMap);
 248                 // create tapi Node
 249                 Node roadmNode = createRoadmTapiNode(orNodeId, onepMap);
 250                 mergeNodeinTopology(Map.of(roadmNode.key(), roadmNode));
 251                 mergeSipsinContext(this.sipMap);
 252                 // TODO add states corresponding to device config -> based on mapping.
 253                 // This should be possible after Gilles work is merged
 254
 255                 // rdm to rdm link creation if neighbour roadm is mounted
 256                 LOG.info("checking if neighbor roadm exists");
 257                 Map<LinkKey, Link> rdm2rdmLinks =
 258                     this.linkDiscovery.readLLDP(new NodeId(orNodeId), orNodeVersion, this.tapiTopoUuid);
 259                 if (!rdm2rdmLinks.isEmpty()) {
 260                     mergeLinkinTopology(rdm2rdmLinks);
 261                 }
 262                 LOG.info("TAPI node for or node {} successfully merged", orNodeId);
 263                 break;
 264
 265             case Xpdr:
 266                 Map<Integer, String> xpdrMap = new HashMap<>();
 267                 for (Mapping mapping : node.nonnullMapping().values().stream()
 268                         .filter(k -> k.getLogicalConnectionPoint().contains("NETWORK"))
 269                         .collect(Collectors.toList())) {
 270                     Integer xpdrNb =
 271                         Integer.parseInt(mapping.getLogicalConnectionPoint().split("XPDR")[1].split("-")[0]);
 272                     String nodeId = node.getNodeId() + TapiStringConstants.XXPDR + xpdrNb;
 273                     if (xpdrMap.containsKey(xpdrNb)) {
 274                         continue;
 275                     }
 276                     List<Mapping> xpdrNetMaps = node.nonnullMapping().values().stream()
 277                         .filter(k -> k.getLogicalConnectionPoint()
 278                             .contains("XPDR" + xpdrNb + TapiStringConstants.NETWORK))
 279                         .collect(Collectors.toList());
 280                     List<Mapping> xpdrClMaps = node.nonnullMapping().values().stream()
 281                         .filter(k -> k.getLogicalConnectionPoint()
 282                             .contains("XPDR" + xpdrNb + TapiStringConstants.CLIENT))
 283                         .collect(Collectors.toList());
 284                     xpdrMap.put(xpdrNb, node.getNodeId());
 285                     // create switching pool
 286                     OduSwitchingPools oorOduSwitchingPool =
 287                         createSwitchPoolForXpdr(mapping.getXpdrType(), xpdrClMaps, xpdrNetMaps, xpdrNb);
 288                     // add nodes and sips to tapi context
 289                     mergeNodeinTopology(new HashMap<>(
 290                         // node transformation
 291                         transformXpdrToTapiNode(
 292                             nodeId, xpdrClMaps, xpdrNetMaps, mapping.getXpdrType(), oorOduSwitchingPool)));
 293                     mergeSipsinContext(this.sipMap);
 294                 }
 295                 LOG.info("TAPI node for or node {} successfully merged", orNodeId);
 296                 break;
 297
 298             default:
 299                 break;
 300         }
 301         // Device not managed yet
 302     }
 303
 304     @Override
 305     public void updateTapiTopology(String nodeId, Mapping mapping) {
 306         List<Uuid> changedOneps = updateNeps(mapping, getChangedNodeUuids(nodeId, mapping));
 307         updateLinks(changedOneps, mapping);
 308         sendNotification(changedOneps, mapping);
 309         LOG.info("Updated TAPI topology successfully.");
 310     }
 311
 312     @SuppressWarnings("rawtypes")
 313     private void sendNotification(List<Uuid> changedOneps, Mapping mapping) {
 314         try {
 315             notificationPublishService.putNotification(
 316                 new NotificationBuilder()
 317                     .setNotificationType(NOTIFICATIONTYPEATTRIBUTEVALUECHANGE.VALUE)
 318                     // .setTargetObjectType(ObjectType.NODEEDGEPOINT)
 319                     //TODO: Change this : modification in Models 2.4 does not provide for Object type Node EdgePoint
 320                     .setTargetObjectType(TOPOLOGYOBJECTTYPENODEEDGEPOINT.VALUE)
 321                     .setChangedAttributes(getChangedAttributes(changedOneps, mapping))
 322                     .setUuid(tapiTopoUuid)
 323                     .build());
 324         } catch (InterruptedException e) {
 325             LOG.error("Could not send notification");
 326         }
 327     }
 328
 329     private Map<ChangedAttributesKey, ChangedAttributes> getChangedAttributes(
 330             List<Uuid> changedOneps, Mapping mapping) {
 331         Map<ChangedAttributesKey, ChangedAttributes> changedAttributes = new HashMap<>();
 332         String operState = mapping.getPortOperState();
 333         String oldState = operState.equals("InService") ? "OutOfService" : "InService";
 334         for (Uuid nep : changedOneps) {
 335             String nepVal = nep.getValue();
 336             changedAttributes.put(
 337                 new ChangedAttributesKey(nepVal),
 338                 new ChangedAttributesBuilder()
 339                     .setValueName(nepVal)
 340                     .setOldValue(oldState)
 341                     .setNewValue(operState)
 342                     .build());
 343         }
 344         return changedAttributes;
 345     }
 346
 347     private void updateLinks(List<Uuid> changedOneps, Mapping mapping) {
 348         try {
 349             Optional<Topology> optTopology =
 350                 this.networkTransactionService.read(
 351                         LogicalDatastoreType.OPERATIONAL,
 352                         InstanceIdentifier.builder(Context.class)
 353                             .augmentation(Context1.class)
 354                             .child(TopologyContext.class)
 355                             .child(Topology.class, new TopologyKey(tapiTopoUuid))
 356                             .build())
 357                     .get();
 358             if (optTopology.isEmpty()) {
 359                 LOG.error("Could not update TAPI links");
 360                 return;
 361             }
 362             int nbAffectedLinks = 0;
 363             LOG.info("UUIDofAffectedONEPS = {} ", changedOneps);
 364             AdministrativeState newAdmState = transformAdminState(mapping.getPortAdminState());
 365             OperationalState newOprState = transformOperState(mapping.getPortOperState());
 366             for (Link link : optTopology.orElseThrow().nonnullLink().values()) {
 367                 List<Uuid> linkNeps = Objects.requireNonNull(link.getNodeEdgePoint()).values().stream()
 368                         .map(NodeEdgePointRef::getNodeEdgePointUuid)
 369                         .collect(Collectors.toList());
 370                 LOG.info("LinkEndPointsUUID = {} for link Name {}", linkNeps, link.getName());
 371                 if (Collections.disjoint(changedOneps, linkNeps)) {
 372                     continue;
 373                 }
 374                 this.networkTransactionService.merge(
 375                     LogicalDatastoreType.OPERATIONAL,
 376                     InstanceIdentifier.builder(Context.class)
 377                         .augmentation(Context1.class)
 378                         .child(TopologyContext.class)
 379                         .child(Topology.class, new TopologyKey(tapiTopoUuid))
 380                         .child(Link.class, new LinkKey(link.getUuid()))
 381                         .build(),
 382                     new LinkBuilder()
 383                         .setUuid(link.getUuid())
 384                         .setAdministrativeState(newAdmState)
 385                         .setOperationalState(newOprState)
 386                         .build());
 387                 nbAffectedLinks++ ;
 388             }
 389             LOG.info("AffectedLinksNb = {} ", nbAffectedLinks);
 390             this.networkTransactionService.commit().get();
 391         } catch (InterruptedException | ExecutionException e) {
 392             LOG.error("Could not update TAPI links");
 393         }
 394     }
 395
 396     private List<Uuid> updateNeps(Mapping mapping, List<Uuid> uuids) {
 397         List<Uuid> changedOneps = new ArrayList<>();
 398         AdministrativeState newAdmState = transformAdminState(mapping.getPortAdminState());
 399         OperationalState newOprState = transformOperState(mapping.getPortOperState());
 400         for (Uuid nodeUuid : uuids) {
 401             try {
 402                 Optional<Node> optionalNode =
 403                     this.networkTransactionService.read(
 404                             LogicalDatastoreType.OPERATIONAL,
 405                             InstanceIdentifier.builder(Context.class)
 406                                 .augmentation(Context1.class)
 407                                 .child(TopologyContext.class)
 408                                 .child(Topology.class, new TopologyKey(tapiTopoUuid))
 409                                 .child(Node.class, new NodeKey(nodeUuid))
 410                                 .build())
 411                         .get();
 412                 if (optionalNode.isEmpty()) {
 413                     continue;
 414                 }
 415                 for (OwnedNodeEdgePoint onep : optionalNode.orElseThrow().getOwnedNodeEdgePoint().values().stream()
 416                         .filter(onep -> ((Name) onep.getName().values().toArray()[0]).getValue()
 417                                 .contains(mapping.getLogicalConnectionPoint()))
 418                         .collect(Collectors.toList())) {
 419                     changedOneps.add(onep.getUuid());
 420                     updateSips(mapping, onep);
 421                     this.networkTransactionService.merge(
 422                         LogicalDatastoreType.OPERATIONAL,
 423                         InstanceIdentifier.builder(Context.class)
 424                             .augmentation(Context1.class)
 425                             .child(TopologyContext.class)
 426                             .child(Topology.class, new TopologyKey(tapiTopoUuid))
 427                             .child(Node.class, new NodeKey(nodeUuid))
 428                             .child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(onep.getUuid()))
 429                             .build(),
 430                         new OwnedNodeEdgePointBuilder()
 431                             .setUuid(onep.getUuid())
 432                             .addAugmentation(
 433                                 new OwnedNodeEdgePoint1Builder().setCepList(getUpdatedCeps(mapping, onep)).build())
 434                             .setAdministrativeState(newAdmState)
 435                             .setOperationalState(newOprState)
 436                             .build());
 437                     LOG.info("UpdatedNEP {} of UUID {} to ADMIN {} OPER {}",
 438                         onep.getName(), onep.getUuid(), newAdmState, newOprState);
 439                 }
 440                 this.networkTransactionService.commit().get();
 441             } catch (InterruptedException | ExecutionException e) {
 442                 LOG.error("Could not update TAPI NEP");
 443             }
 444         }
 445         return changedOneps;
 446     }
 447
 448     private CepList getUpdatedCeps(Mapping mapping, OwnedNodeEdgePoint onep) {
 449         OwnedNodeEdgePoint1 onep1 = onep.augmentation(OwnedNodeEdgePoint1.class);
 450         if (onep1 == null) {
 451             return new CepListBuilder().setConnectionEndPoint(new HashMap<>()).build();
 452         }
 453         CepList onep1CepList = onep1.getCepList();
 454         if (onep1CepList == null) {
 455             return new CepListBuilder().setConnectionEndPoint(new HashMap<>()).build();
 456         }
 457         var onep1CepListConnEndPoint = onep1CepList.getConnectionEndPoint();
 458         if (onep1CepListConnEndPoint == null) {
 459             return new CepListBuilder().setConnectionEndPoint(new HashMap<>()).build();
 460         }
 461         Map<ConnectionEndPointKey, ConnectionEndPoint> cepMap = new HashMap<>();
 462         OperationalState newOprState = transformOperState(mapping.getPortOperState());
 463         for (Map.Entry<ConnectionEndPointKey, ConnectionEndPoint> entry : onep1CepListConnEndPoint.entrySet()) {
 464             cepMap.put(
 465                 entry.getKey(),
 466                 new ConnectionEndPointBuilder(entry.getValue()).setOperationalState(newOprState).build());
 467         }
 468         return new CepListBuilder().setConnectionEndPoint(cepMap).build();
 469     }
 470
 471     private List<Uuid> getChangedNodeUuids(String nodeId, Mapping mapping) {
 472         if (nodeId.contains("ROADM")) {
 473             return new ArrayList<>(List.of(new Uuid(
 474                 UUID.nameUUIDFromBytes(
 475                         (String.join("+", nodeId, TapiStringConstants.PHTNC_MEDIA)).getBytes(StandardCharsets.UTF_8))
 476                     .toString())));
 477         }
 478         if (nodeId.contains("PDR")) {
 479             LOG.debug("ANALYSING change in {}", nodeId);
 480             return new ArrayList<>(List.of(new Uuid(
 481                 UUID.nameUUIDFromBytes(
 482                         (String.join("+",
 483                                 //xpdrNodeId,
 484                                 nodeId + TapiStringConstants.XXPDR
 485                                     // + xpdrNb,
 486                                     + Integer.parseInt(
 487                                         mapping.getLogicalConnectionPoint().split("XPDR")[1].split("-")[0]),
 488                                 TapiStringConstants.XPDR))
 489                             .getBytes(StandardCharsets.UTF_8))
 490                     .toString())));
 491         }
 492         LOG.error("Updating this device is currently not supported");
 493         return new ArrayList<>();
 494     }
 495
 496     private void updateSips(Mapping mapping, OwnedNodeEdgePoint onep) {
 497         if (onep.getMappedServiceInterfacePoint() == null) {
 498             return;
 499         }
 500         AdministrativeState newAdmState = transformAdminState(mapping.getPortAdminState());
 501         OperationalState newOprState = transformOperState(mapping.getPortOperState());
 502         for (MappedServiceInterfacePoint msip : onep.getMappedServiceInterfacePoint().values()) {
 503             this.networkTransactionService.merge(
 504                 LogicalDatastoreType.OPERATIONAL,
 505                 InstanceIdentifier
 506                     .builder(Context.class)
 507                     .child(ServiceInterfacePoint.class,
 508                             new ServiceInterfacePointKey(msip.getServiceInterfacePointUuid()))
 509                     .build(),
 510                 new ServiceInterfacePointBuilder()
 511                     .setUuid(msip.getServiceInterfacePointUuid())
 512                     .setAdministrativeState(newAdmState)
 513                     .setOperationalState(newOprState)
 514                     .build());
 515         }
 516     }
 517
 518     private Map<NodeKey, Node> transformXpdrToTapiNode(String nodeId, List<Mapping> xpdrClMaps,
 519             List<Mapping> xpdrNetMaps, XpdrNodeTypes xponderType, OduSwitchingPools oorOduSwitchingPool) {
 520         LOG.info("creation of a DSR/ODU node for {}", nodeId);
 521         String nameVal = String.join("+", nodeId, TapiStringConstants.XPDR);
 522         Name nameDsr = new NameBuilder().setValueName("dsr/odu node name").setValue(nameVal).build();
 523         Name nameOtsi =  new NameBuilder().setValueName("otsi node name").setValue(nameVal).build();
 524         Name nameNodeType = new NameBuilder().setValueName("Node Type").setValue(getNodeType(xponderType)).build();
 525         Node dsrNode = createTapiXpdrNode(
 526             Map.of(nameDsr.key(), nameDsr, nameOtsi.key(), nameOtsi, nameNodeType.key(), nameNodeType),
 527             Set.of(LayerProtocolName.DSR, LayerProtocolName.ODU,
 528                 LayerProtocolName.DIGITALOTN, LayerProtocolName.PHOTONICMEDIA),
 529             nodeId, new Uuid(UUID.nameUUIDFromBytes(nameVal.getBytes(StandardCharsets.UTF_8)).toString()),
 530             xpdrClMaps, xpdrNetMaps, xponderType, oorOduSwitchingPool);
 531         return new HashMap<>(Map.of(dsrNode.key(), dsrNode));
 532     }
 533
 534     private OduSwitchingPools createSwitchPoolForXpdr(
 535             XpdrNodeTypes xpdrType, List<Mapping> xpdrClMaps, List<Mapping> xpdrNetMaps, Integer xpdrNb) {
 536         //TODO are switching pool correct here??
 537         switch (xpdrType) {
 538             case Tpdr:
 539                 return createTpdrSwitchPool(xpdrNetMaps);
 540             case Mpdr:
 541                 return createMuxSwitchPool(xpdrClMaps, xpdrNetMaps, xpdrNb);
 542             case Switch:
 543                 return createSwtchSwitchPool(xpdrClMaps, xpdrNetMaps, xpdrNb);
 544             // case Regen:
 545             // case RegenUni:
 546             default:
 547                 LOG.warn("Xpdr type {} not supported", xpdrType);
 548         }
 549         return null;
 550     }
 551
 552     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> transformSrgToOnep(
 553                 String orNodeId, Map<String, List<Mapping>> mapSrg) {
 554         LOG.debug("CREATENEP transformSrgToOnep, ListOfMapping {}, of NodeId {} ", mapSrg, orNodeId);
 555         Map<String, TerminationPoint1> tpMap = new HashMap<>();
 556         //List<TerminationPoint> tpList = new ArrayList<>();
 557         for (Map.Entry<String, List<Mapping>> entry : mapSrg.entrySet()) {
 558             // For each srg node. Loop through the LCPs and create neps and sips for PP
 559             for (Mapping m : entry.getValue()) {
 560                 String tpId = m.getLogicalConnectionPoint();
 561                 String overlayNodeId = String.join("-", orNodeId, tpId.split("\\-")[0]);
 562                 if (!tpId.contains("PP")) {
 563                     LOG.info("LCP {} is not an external TP of SRG node", tpId);
 564                     continue;
 565                 }
 566                 int counter = 50;
 567                 do {
 568                     var netTP1fromDS = getNetworkTerminationPoint1FromDatastore(overlayNodeId, tpId);
 569                     if (netTP1fromDS != null) {
 570                         //tpList.add(netTP1fromDS);
 571                         tpMap.put(tpId, netTP1fromDS);
 572                         LOG.debug("LCP {} is not empty for augmentation TP1", tpId);
 573                         break;
 574                     }
 575                     try {
 576                         Thread.sleep(1);
 577                     } catch (InterruptedException e) {
 578                         // TODO Auto-generated catch block
 579                         LOG.debug("Waiting until PP is backported in Topology, Exception raised", e);
 580                     }
 581                     counter--;
 582                 } while (counter > 0);
 583                 if (counter == 0) {
 584                     LOG.error("CREATENEP transformSrgToOnep, No Tp1 found in topology for LCP {}, of NodeId {} ",
 585                         tpId, overlayNodeId);
 586                 }
 587                 if (getNetworkTerminationPoint11FromDatastore(overlayNodeId, tpId) == null) {
 588                     LOG.error("CREATENEP transformSrgToOnep, No Tp11 found in topology for LCP {}, of NodeId {} ",
 589                         tpId, overlayNodeId);
 590                 } else {
 591                     LOG.info("LCP {} is not empty for augmentation TP11", tpId);
 592                 }
 593             }
 594         }
 595         LOG.debug("TransformSRGToONep for tps {}, of NodeId {} ",
 596             tpMap.entrySet().stream().map(tp -> tp.getKey()).collect(Collectors.toList()), orNodeId);
 597         return populateNepsForRdmNode(orNodeId, tpMap, false, TapiStringConstants.PHTNC_MEDIA_OTS);
 598     }
 599
 600     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> transformDegToOnep(
 601                 String orNodeId, Map<String, List<Mapping>> mapDeg) {
 602         LOG.debug("CREATENEP transformDegToOnep, ListOfMapping {}, of NodeId {} ", mapDeg, orNodeId);
 603         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> degOnepMap = new HashMap<>();
 604         Map<String, TerminationPoint1> tpMap = new HashMap<>();
 605         //List<TerminationPoint> tpList = new ArrayList<>();
 606         for (Map.Entry<String, List<Mapping>> entry : mapDeg.entrySet()) {
 607             // For each degree node. Loop through the LCPs and create neps and sips for TTP
 608             for (Mapping m:entry.getValue()) {
 609                 String tpId = m.getLogicalConnectionPoint();
 610                 if (!tpId.contains("TTP")) {
 611                     LOG.info("LCP {} is not an external TP of DEGREE node", tpId);
 612                     continue;
 613                 }
 614                 String overlayNodeId = String.join("-", orNodeId, tpId.split("\\-")[0]);
 615                 var netTP1fromDS = getNetworkTerminationPoint1FromDatastore(overlayNodeId, tpId);
 616                 if (netTP1fromDS == null) {
 617                     LOG.error("CREATENEP transformDegToOnep, No Tp found in topology for LCP {}, of NodeId {} ",
 618                         tpId, overlayNodeId);
 619                     continue;
 620                 }
 621                 //tpList.add(getNetworkTerminationPointFromDatastore(overlayNodeId, tpId));
 622                 tpMap.put(tpId, netTP1fromDS);
 623                 LOG.info("LCP {} is not empty for augmentation TP1", tpId);
 624             }
 625         }
 626         degOnepMap.putAll(populateNepsForRdmNode(orNodeId, tpMap, false, TapiStringConstants.PHTNC_MEDIA_OTS));
 627         degOnepMap.putAll(populateNepsForRdmNode(orNodeId, tpMap, false, TapiStringConstants.PHTNC_MEDIA_OMS));
 628         return degOnepMap;
 629     }
 630
 631     private List<String> getRoadmNodelist(List<Mapping> mappingList) {
 632         List<String> nodeShardList = new ArrayList<>();
 633         for (Mapping mapping : mappingList) {
 634             // TODO -> maybe we need to check the id based on the version
 635             String str = mapping.getLogicalConnectionPoint().split("-")[0];
 636             LOG.info("LCP = {}", str);
 637             if (!nodeShardList.contains(str)) {
 638                 nodeShardList.add(str);
 639             }
 640         }
 641         return nodeShardList;
 642     }
 643
 644     @Override
 645     public void deleteTapinode(String nodeId) {
 646         // TODO: check for null objects
 647         // Check if it is ROADM or XPDR --> create the uuids of the node and delete from topology the node.
 648         // This will delete NEPs. Then check for links that have this node and delete them.
 649         // Then check SIPs and delete them. Then services and connections with SIPs and put them to another state.
 650         LOG.info("Deleting node {} from TAPI topology", nodeId);
 651         InstanceIdentifier<Topology> topologyIID = InstanceIdentifier.builder(Context.class)
 652                 .augmentation(Context1.class)
 653                 .child(TopologyContext.class)
 654                 .child(Topology.class, new TopologyKey(tapiTopoUuid))
 655                 .build();
 656         Topology topology = null;
 657         try {
 658             Optional<Topology> optTopology =
 659                     this.networkTransactionService.read(LogicalDatastoreType.OPERATIONAL, topologyIID).get();
 660             if (optTopology.isEmpty()) {
 661                 LOG.error("No topology object present. Error deleting node {}", nodeId);
 662                 return;
 663             }
 664             topology = optTopology.orElseThrow();
 665         } catch (InterruptedException | ExecutionException e) {
 666             LOG.error("Couldnt read tapi topology from datastore", e);
 667         }
 668         if (topology == null) {
 669             LOG.error("Topology is null, nothing to delete");
 670             return;
 671         }
 672         if (topology.getNode() == null) {
 673             LOG.error("No nodes in topology");
 674             return;
 675         }
 676         if (nodeId.contains("ROADM")) {
 677             if (topologicalMode.equals("Full")) {
 678              // Node is in photonic media layer and UUID can be built from nodeId + PHTN_MEDIA
 679                 Uuid nodeUuid = new Uuid(
 680                     UUID.nameUUIDFromBytes(
 681                             (String.join("+", nodeId,TapiStringConstants.PHTNC_MEDIA)).getBytes(StandardCharsets.UTF_8))
 682                         .toString());
 683                 deleteNodeFromTopo(nodeUuid);
 684             } else {
 685                 LOG.info("Abstracted Topo Mode in TAPI topology Datastore for OR topology representation. Node"
 686                     + " {} is not represented in the abstraction and will not be deleted", nodeId);
 687             }
 688         }
 689         if (nodeId.contains("XPDR") || nodeId.contains("SPDR") || nodeId.contains("MXPDR")) {
 690             // Node is either XPDR, MXPDR or SPDR. Retrieve nodes from topology and check names
 691             for (Node tapiNode:topology.getNode().values()) {
 692                 if (tapiNode.getName().values().stream().anyMatch(name -> name.getValue().contains(nodeId))) {
 693                     // Found node we need to delete
 694                     deleteNodeFromTopo(tapiNode.getUuid());
 695                 }
 696             }
 697         }
 698         // Delete links of topology
 699         Map<LinkKey, Link> linkMap = topology.getLink();
 700         if (linkMap != null) {
 701             for (Link link:linkMap.values()) {
 702                 if (link.getName().values().stream().anyMatch(name -> name.getValue().contains(nodeId))) {
 703                     deleteLinkFromTopo(link.getUuid());
 704                 }
 705             }
 706         }
 707         // Delete sips of sip map
 708         InstanceIdentifier<Context> contextIID = InstanceIdentifier.builder(Context.class).build();
 709         Context context = null;
 710         try {
 711             Optional<Context> optContext =
 712                 this.networkTransactionService.read(LogicalDatastoreType.OPERATIONAL, contextIID).get();
 713             if (optContext.isEmpty()) {
 714                 LOG.error("No context object present in datastore.");
 715                 return;
 716             }
 717             context = optContext.orElseThrow();
 718         } catch (InterruptedException | ExecutionException e) {
 719             LOG.error("Couldnt read tapi context from datastore", e);
 720         }
 721         if (context == null) {
 722             LOG.error("Context is null, nothing to delete");
 723             return;
 724         }
 725         Map<ServiceInterfacePointKey, ServiceInterfacePoint> sips = context.getServiceInterfacePoint();
 726         if (sips == null) {
 727             return;
 728         }
 729         for (ServiceInterfacePoint sip:sips.values()) {
 730             if (sip.getName().values().stream().anyMatch(name -> name.getValue().contains(nodeId))) {
 731                 // Update state of services that have this sip as an endpoint and also connections
 732                 updateConnectivityServicesState(sip.getUuid(), nodeId);
 733                 deleteSipFromTopo(sip.getUuid());
 734             }
 735         }
 736     }
 737
 738     private Node createTapiXpdrNode(
 739             Map<NameKey, Name> nameMap, Set<LayerProtocolName> layerProtocols,
 740             String nodeId, Uuid nodeUuid,
 741             List<Mapping> xpdrClMaps, List<Mapping> xpdrNetMaps,
 742             XpdrNodeTypes xponderType, OduSwitchingPools oorOduSwitchingPool) {
 743         if (!layerProtocols.contains(LayerProtocolName.DSR)
 744                 || !layerProtocols.contains(LayerProtocolName.PHOTONICMEDIA)) {
 745             LOG.error("Undefined LayerProtocolName for {} node {}",
 746                 nameMap.get(nameMap.keySet().iterator().next()).getValueName(),
 747                 nameMap.get(nameMap.keySet().iterator().next()).getValue());
 748         }
 749         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl =
 750             new HashMap<>(createXpdrDsrOduNeps(nodeId, xpdrClMaps, xpdrNetMaps, xponderType));
 751         Rule rule = new RuleBuilder()
 752                 .setLocalId("forward")
 753                 .setForwardingRule(FORWARDINGRULEMAYFORWARDACROSSGROUP.VALUE)
 754                 .setRuleType(new HashSet<>(Set.of(RuleType.FORWARDING)))
 755                 .build();
 756         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupList =
 757             createNodeRuleGroupForDsrNode(nodeId, oorOduSwitchingPool, new HashMap<>(Map.of(rule.key(), rule)), onepl);
 758         onepl.putAll(createXpdrPhtnMdNeps(nodeId, xpdrNetMaps));
 759         LOG.debug("TapiNetworkModelServiceImpl line 721, total NEP map = {}", onepl);
 760
 761         // Empty random creation of mandatory fields for avoiding errors....
 762         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 763             .setCostAlgorithm("Restricted Shortest Path - RSP")
 764             .setCostName("HOP_COUNT")
 765             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 766             .build();
 767         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 768             .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 769             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 770             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 771             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 772             .setTrafficPropertyName("FIXED_LATENCY")
 773             .build();
 774         RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
 775             .setRiskCharacteristicName("risk characteristic")
 776             .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
 777             .build();
 778         RiskParameterPac riskParamPac = new RiskParameterPacBuilder()
 779             .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
 780             .build();
 781         Node builtNode = new NodeBuilder()
 782             .setUuid(nodeUuid)
 783             .setName(nameMap)
 784             .setLayerProtocolName(layerProtocols)
 785             .setAdministrativeState(AdministrativeState.UNLOCKED)
 786             .setOperationalState(OperationalState.ENABLED)
 787             .setLifecycleState(LifecycleState.INSTALLED)
 788             .setOwnedNodeEdgePoint(onepl)
 789             .setNodeRuleGroup(nodeRuleGroupList)
 790             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 791             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 792             .setErrorCharacteristic("error")
 793             .setLossCharacteristic("loss")
 794             .setRepeatDeliveryCharacteristic("repeat delivery")
 795             .setDeliveryOrderCharacteristic("delivery order")
 796             .setUnavailableTimeCharacteristic("unavailable time")
 797             .setServerIntegrityProcessCharacteristic("server integrity process")
 798             .setRiskParameterPac(riskParamPac)
 799             .build();
 800         List<PhotonicMediaNodeEdgePointSpec> pmnepspecList = new ArrayList<>();
 801         for (Map.Entry<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> entry :
 802                 builtNode.getOwnedNodeEdgePoint().entrySet()) {
 803             if (entry.getValue().getSupportedCepLayerProtocolQualifierInstances().stream()
 804                         .filter(sclpqi -> sclpqi.getLayerProtocolQualifier().equals(PHOTONICLAYERQUALIFIEROTS.VALUE))
 805                         .collect(Collectors.toList()).isEmpty()) {
 806                 continue;
 807             }
 808             var aug1 = entry.getValue().augmentationOrElseThrow(
 809                                 org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121
 810                             .OwnedNodeEdgePoint1.class);
 811             if (aug1 == null) {
 812                 continue;
 813             }
 814             var phMedNepSpec = aug1.getPhotonicMediaNodeEdgePointSpec();
 815             if (phMedNepSpec != null) {
 816                 pmnepspecList.add(phMedNepSpec);
 817             }
 818         }
 819         LOG.debug("TapiNetworkModelServiceImpl line 775, List of non empty PMNEPSEC is = {}", pmnepspecList);
 820         return builtNode;
 821     }
 822
 823     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> createXpdrPhtnMdNeps(
 824             String nodeId, List<Mapping> xpdrNetMaps) {
 825         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl = new HashMap<>();
 826         // eNep creation on otsi node
 827         for (Mapping mapping : xpdrNetMaps) {
 828             var lcp = mapping.getLogicalConnectionPoint();
 829             String onedNameVal = String.join("+", nodeId, TapiStringConstants.PHTNC_MEDIA_OTS, lcp);
 830             Name onedName = new NameBuilder().setValueName("eNodeEdgePoint").setValue(onedNameVal).build();
 831             var supOpModes = mapping.getSupportedOperationalMode();
 832             List<String> opModeList = supOpModes == null ? new ArrayList<>() : new ArrayList<>(supOpModes);
 833             AdministrativeState newAdmState = transformAdminState(mapping.getPortAdminState());
 834             OperationalState newOprState = transformOperState(mapping.getPortOperState());
 835             OwnedNodeEdgePoint onep = createNep(
 836                 nodeId,
 837                 new Uuid(UUID.nameUUIDFromBytes(onedNameVal.getBytes(StandardCharsets.UTF_8)).toString()),
 838                 lcp, Map.of(onedName.key(), onedName),
 839                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, true,
 840                 String.join("+", nodeId, TapiStringConstants.PHTNC_MEDIA_OTS),
 841                 new ArrayList<>(mapping.getSupportedInterfaceCapability()), opModeList, newOprState, newAdmState);
 842             onepl.put(onep.key(), onep);
 843         // OTSi_MC Nep creation on otsi node
 844             String onedNameVal2 = String.join("+", nodeId, TapiStringConstants.OTSI_MC, lcp);
 845             Name onedName2 = new NameBuilder().setValueName("PhotMedNodeEdgePoint").setValue(onedNameVal2).build();
 846             OwnedNodeEdgePoint onep2 = createNep(
 847                 nodeId,
 848                 new Uuid(UUID.nameUUIDFromBytes(onedNameVal2.getBytes(StandardCharsets.UTF_8)).toString()),
 849                 lcp, Map.of(onedName2.key(), onedName2),
 850                 LayerProtocolName.PHOTONICMEDIA, LayerProtocolName.PHOTONICMEDIA, false,
 851                 String.join("+", nodeId, TapiStringConstants.OTSI_MC),
 852                 new ArrayList<>(mapping.getSupportedInterfaceCapability()), opModeList, newOprState, newAdmState);
 853             onepl.put(onep2.key(), onep2);
 854         }
 855         return onepl;
 856     }
 857
 858     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> createXpdrDsrOduNeps(
 859             String nodeId, List<Mapping> xpdrClMaps, List<Mapping> xpdrNetMaps, XpdrNodeTypes xponderType) {
 860         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl = new HashMap<>();
 861         // client nep creation on DSR node
 862         for (Mapping mapping : xpdrClMaps) {
 863             var lcp = mapping.getLogicalConnectionPoint();
 864             String nepvalue = String.join("+", nodeId, TapiStringConstants.DSR, lcp);
 865             LOG.info("Client NEP = {}", nepvalue);
 866             Name name = new NameBuilder()
 867                 .setValue(nepvalue)
 868                 .setValueName(OpenroadmNodeType.TPDR.getName().equalsIgnoreCase(xponderType.getName())
 869                         ? "100G-tpdr" : "NodeEdgePoint_C")
 870                 .build();
 871             AdministrativeState newAdmState = transformAdminState(mapping.getPortAdminState());
 872             OperationalState newOprState = transformOperState(mapping.getPortOperState());
 873             OwnedNodeEdgePoint onep = createNep(
 874                 nodeId, new Uuid(UUID.nameUUIDFromBytes(nepvalue.getBytes(StandardCharsets.UTF_8)).toString()),
 875                 lcp, Map.of(name.key(), name), LayerProtocolName.DSR, LayerProtocolName.DSR, true,
 876                 String.join("+", nodeId, TapiStringConstants.DSR),
 877                 new ArrayList<>(mapping.getSupportedInterfaceCapability()), null, newOprState, newAdmState);
 878             onepl.put(onep.key(), onep);
 879         // network nep creation on E_ODU node
 880             String onedNameVal = String.join("+", nodeId, TapiStringConstants.E_ODU, lcp);
 881             LOG.info("eODU NEP = {}", onedNameVal);
 882             Name onedName = new NameBuilder().setValueName("eNodeEdgePoint_N").setValue(onedNameVal).build();
 883             OwnedNodeEdgePoint onep2 = createNep(
 884                 nodeId, new Uuid(UUID.nameUUIDFromBytes(onedNameVal.getBytes(StandardCharsets.UTF_8)).toString()),
 885                 lcp, Map.of(onedName.key(), onedName), LayerProtocolName.ODU, LayerProtocolName.DSR, true,
 886                 String.join("+", nodeId, TapiStringConstants.E_ODU),
 887                 new ArrayList<>(mapping.getSupportedInterfaceCapability()), null, newOprState, newAdmState);
 888             onepl.put(onep2.key(), onep2);
 889         }
 890         // network nep creation on I_ODU node
 891         for (Mapping mapping : xpdrNetMaps) {
 892             var lcp = mapping.getLogicalConnectionPoint();
 893             String onedNameVal = String.join("+", nodeId, TapiStringConstants.I_ODU, lcp);
 894             LOG.info("iODU NEP = {}", onedNameVal);
 895             Name onedName = new NameBuilder().setValueName("iNodeEdgePoint_N").setValue(onedNameVal).build();
 896             OwnedNodeEdgePoint onep = createNep(
 897                 nodeId, new Uuid(UUID.nameUUIDFromBytes(onedNameVal.getBytes(StandardCharsets.UTF_8)).toString()),
 898                 lcp, Map.of(onedName.key(), onedName), LayerProtocolName.ODU, LayerProtocolName.DSR, true,
 899                 String.join("+", nodeId, TapiStringConstants.I_ODU),
 900                 new ArrayList<>(mapping.getSupportedInterfaceCapability()),
 901                 null, transformOperState(mapping.getPortOperState()),transformAdminState(mapping.getPortAdminState()));
 902             onepl.put(onep.key(), onep);
 903         }
 904         return onepl;
 905     }
 906
 907     private OperationalState transformOperState(String operString) {
 908         return org.opendaylight.transportpce.networkmodel.util.TopologyUtils.setNetworkOperState(operString)
 909                 .equals(State.InService) ? OperationalState.ENABLED : OperationalState.DISABLED;
 910     }
 911
 912     private AdministrativeState transformAdminState(String adminString) {
 913         return org.opendaylight.transportpce.networkmodel.util.TopologyUtils.setNetworkAdminState(adminString)
 914                 .equals(AdminStates.InService) ? AdministrativeState.UNLOCKED : AdministrativeState.LOCKED;
 915     }
 916
 917     private OwnedNodeEdgePoint createNep(String nodeId, Uuid nepUuid, String tpid, Map<NameKey, Name> nepNames,
 918             LayerProtocolName nepProtocol, LayerProtocolName nodeProtocol, boolean withSip, String keyword,
 919             List<SupportedIfCapability> sicList, List<String> opModeList,
 920             OperationalState operState, AdministrativeState adminState) {
 921         List<SupportedInterfaceCapability> sicListTemp = new ArrayList<>();
 922         List<OperationalModeKey> keyedOpModeList = new ArrayList<>();
 923         for (SupportedIfCapability supInterCapa : sicList) {
 924             sicListTemp.add(new SupportedInterfaceCapabilityBuilder()
 925                     .withKey(new SupportedInterfaceCapabilityKey(supInterCapa))
 926                     .setIfCapType(supInterCapa)
 927                     .build());
 928         }
 929         Collection<SupportedInterfaceCapability> sicColl = sicListTemp;
 930         OwnedNodeEdgePointBuilder onepBldr = new OwnedNodeEdgePointBuilder()
 931                 .setUuid(nepUuid)
 932                 .setLayerProtocolName(nepProtocol)
 933                 .setName(nepNames);
 934         if (withSip) {
 935             onepBldr.setMappedServiceInterfacePoint(
 936                 this.tapiFactory.createMSIP(1, nepProtocol, tpid, keyword, sicColl, operState, adminState));
 937             this.sipMap.putAll(tapiFactory.getTapiSips());
 938         }
 939         LOG.debug("Node layer {}", nodeProtocol.getName());
 940         onepBldr
 941             .setSupportedCepLayerProtocolQualifierInstances(
 942                 this.tapiFactory.createSupportedCepLayerProtocolQualifier(sicColl, nepProtocol))
 943             .setDirection(Direction.BIDIRECTIONAL)
 944             .setLinkPortRole(PortRole.SYMMETRIC)
 945             .setAdministrativeState(adminState).setOperationalState(operState)
 946             .setLifecycleState(LifecycleState.INSTALLED);
 947         if (!keyword.contains(TapiStringConstants.OTSI_MC) && !keyword.contains(TapiStringConstants.PHTNC_MEDIA_OTS)) {
 948             return onepBldr.build();
 949         }
 950         if (opModeList == null || opModeList.isEmpty()) {
 951             for (SupportedInterfaceCapability sic : sicColl) {
 952                 switch (sic.getIfCapType().toString().split("\\{")[0]) {
 953                     case "IfOCHOTUCnODUCn":
 954                     case "IfOCHOTUCnODUCnUniregen":
 955                     case "IfOCHOTUCnODUCnRegen":
 956                         keyedOpModeList.add(new OperationalModeKey("400G"));
 957                         LOG.warn(TopologyUtils.NOOPMODEDECLARED + "400G rate available", tpid);
 958                         break;
 959                     default:
 960                         continue;
 961                 }
 962                 break;
 963             }
 964             keyedOpModeList.add(new OperationalModeKey("100G"));
 965             LOG.warn(TopologyUtils.NOOPMODEDECLARED + "100G rate available", tpid);
 966         } else {
 967             for (String opMode : opModeList) {
 968                 keyedOpModeList.add(new OperationalModeKey(opMode));
 969             }
 970         }
 971         Map<Double, Double> freqWidthMap = new HashMap<>();
 972         if (getNetworkTerminationPointFromDatastore(nodeId, tpid) == null) {
 973             LOG.error("CREATENEP, No Tp found in topology for LCP {}, of NodeId {} ", tpid, nodeId);
 974         } else {
 975             freqWidthMap = tapiFactory.getXpdrUsedWavelength(getNetworkTerminationPointFromDatastore(nodeId, tpid));
 976         }
 977         OwnedNodeEdgePoint onep = tapiFactory.addPayloadStructureAndPhotSpecToOnep(
 978                 nodeId, freqWidthMap, keyedOpModeList, sicColl, onepBldr, keyword)
 979             .build();
 980         LOG.debug("TapiNetworkServiceImpl line982, onep = {}", onep);
 981         return onep;
 982     }
 983
 984     private Node createRoadmTapiNode(String orNodeId, Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap) {
 985         // UUID and Node Names
 986         Uuid nodeUuid;
 987         Name nodeNames;
 988         if (orNodeId.equals("ROADMINFRA")) {
 989             nodeUuid = new Uuid(
 990                 UUID.nameUUIDFromBytes(TapiStringConstants.RDM_INFRA.getBytes(Charset.forName("UTF-8")))
 991                     .toString());
 992             nodeNames =
 993                 new NameBuilder().setValueName("roadm node name").setValue(TapiStringConstants.RDM_INFRA).build();
 994         } else {
 995             String nodeNamesVal = String.join("+", orNodeId, TapiStringConstants.PHTNC_MEDIA);
 996             nodeUuid = new Uuid(
 997                 UUID.nameUUIDFromBytes(nodeNamesVal.getBytes(StandardCharsets.UTF_8))
 998                     .toString());
 999             nodeNames = new NameBuilder().setValueName("roadm node name").setValue(nodeNamesVal).build();
1000         }
1001         Name nameNodeType =
1002             new NameBuilder().setValueName("Node Type").setValue(OpenroadmNodeType.ROADM.getName()).build();
1003         // Protocol Layer
1004         // Empty random creation of mandatory fields for avoiding errors....
1005         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
1006             .setCostAlgorithm("Restricted Shortest Path - RSP")
1007             .setCostName("HOP_COUNT")
1008             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
1009             .build();
1010         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
1011             .setFixedLatencyCharacteristic(TapiStringConstants.COST_HOP_VALUE)
1012             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
1013             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
1014             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
1015             .setTrafficPropertyName("FIXED_LATENCY")
1016             .build();
1017         RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
1018             .setRiskCharacteristicName("risk characteristic")
1019             .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
1020             .build();
1021         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap =
1022             tapiFactory.createAllNodeRuleGroupForRdmNode(topologicalMode, nodeUuid, orNodeId, onepMap.values());
1023         return new NodeBuilder()
1024             .setUuid(nodeUuid)
1025             .setName(Map.of(nodeNames.key(), nodeNames, nameNodeType.key(), nameNodeType))
1026             .setLayerProtocolName(Set.of(LayerProtocolName.PHOTONICMEDIA))
1027             .setAdministrativeState(AdministrativeState.UNLOCKED)
1028             .setOperationalState(OperationalState.ENABLED)
1029             .setLifecycleState(LifecycleState.INSTALLED)
1030             .setOwnedNodeEdgePoint(onepMap)
1031             .setNodeRuleGroup(nodeRuleGroupMap)
1032             .setInterRuleGroup(
1033                 tapiFactory.createInterRuleGroupForRdmNode(topologicalMode, nodeUuid, orNodeId,
1034                     nodeRuleGroupMap.entrySet().stream().map(e -> e.getKey()).collect(Collectors.toList())))
1035             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
1036             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
1037             .setErrorCharacteristic("error")
1038             .setLossCharacteristic("loss")
1039             .setRepeatDeliveryCharacteristic("repeat delivery")
1040             .setDeliveryOrderCharacteristic("delivery order")
1041             .setUnavailableTimeCharacteristic("unavailable time")
1042             .setServerIntegrityProcessCharacteristic("server integrity process")
1043             .setRiskParameterPac(
1044                 new RiskParameterPacBuilder()
1045                     .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
1046                     .build())
1047             .build();
1048     }
1049
1050     private OduSwitchingPools createTpdrSwitchPool(List<Mapping> xpdrNetMaps) {
1051         Map<NonBlockingListKey, NonBlockingList> nblMap = new HashMap<>();
1052         for (int i = 1; i <= xpdrNetMaps.size(); i++) {
1053             String netLCP = xpdrNetMaps.get(i - 1).getLogicalConnectionPoint();
1054             String netAssoLCP = xpdrNetMaps.get(i - 1).getConnectionMapLcp();
1055             LOG.info("XPDr net LCP = {}", netLCP);
1056             LOG.info("XPDr net associated LCP = {}", netAssoLCP);
1057             NonBlockingList nbl = new NonBlockingListBuilder()
1058                 .setNblNumber(Uint16.valueOf(i))
1059                 .setTpList(new HashSet<>(Set.of(new TpId(netLCP), new TpId(netAssoLCP))))
1060                 .build();
1061             nblMap.put(nbl.key(), nbl);
1062         }
1063         return new OduSwitchingPoolsBuilder()
1064             .setNonBlockingList(nblMap)
1065             .setSwitchingPoolNumber(Uint16.valueOf(1))
1066             .build();
1067     }
1068
1069     private OduSwitchingPools createSwtchSwitchPool(
1070             List<Mapping> xpdrClMaps, List<Mapping> xpdrNetMaps, Integer xpdrNb) {
1071         Set<TpId> tpl = new HashSet<>();
1072         for (int i = 1; i <= xpdrClMaps.size(); i++) {
1073             tpl.add(new TpId("XPDR" + xpdrNb + TapiStringConstants.CLIENT + i));
1074             tpl.add(new TpId("XPDR" + xpdrNb + TapiStringConstants.NETWORK + i));
1075         }
1076         NonBlockingList nbl = new NonBlockingListBuilder().setNblNumber(Uint16.valueOf(1)).setTpList(tpl).build();
1077         return new OduSwitchingPoolsBuilder()
1078             .setSwitchingPoolNumber(Uint16.valueOf(1))
1079             .setSwitchingPoolType(SwitchingPoolTypes.NonBlocking)
1080             .setNonBlockingList(new HashMap<>(Map.of(nbl.key(),nbl)))
1081             .build();
1082     }
1083
1084     private OduSwitchingPools createMuxSwitchPool(List<Mapping> xpdrClMaps, List<Mapping> xpdrNetMaps, Integer xpdrNb) {
1085         Map<NonBlockingListKey, NonBlockingList> nbMap = new HashMap<>();
1086         for (int i = 1; i <= xpdrClMaps.size(); i++) {
1087             NonBlockingList nbl = new NonBlockingListBuilder()
1088                 .setNblNumber(Uint16.valueOf(i))
1089                 .setTpList(
1090                     new HashSet<>(Set.of(
1091                         new TpId("XPDR" + xpdrNb + TapiStringConstants.CLIENT + i),
1092                         new TpId("XPDR" + xpdrNb + "-NETWORK1"))))
1093                 .setAvailableInterconnectBandwidth(Uint32.valueOf(xpdrNetMaps.size() * 10L))
1094                 .setInterconnectBandwidthUnit(Uint32.valueOf(1000000000))
1095                 .build();
1096             nbMap.put(nbl.key(),nbl);
1097         }
1098         return new OduSwitchingPoolsBuilder()
1099                 .setSwitchingPoolNumber(Uint16.valueOf(1))
1100                 .setSwitchingPoolType(SwitchingPoolTypes.NonBlocking)
1101                 .setNonBlockingList(nbMap)
1102                 .build();
1103     }
1104
1105     private Map<NodeRuleGroupKey, NodeRuleGroup> createNodeRuleGroupForDsrNode(String nodeId,
1106             OduSwitchingPools oorOduSwitchingPool, Map<RuleKey, Rule> ruleList,
1107             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepl) {
1108         // create NodeRuleGroup
1109         if (oorOduSwitchingPool == null) {
1110             LOG.info("No switching pool created for node = {}", nodeId);
1111             return new HashMap<>();
1112         }
1113         LOG.debug("ONEPL = {}", onepl.values());
1114         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap = new HashMap<>();
1115         Uuid nodeUuid = new Uuid(
1116             UUID.nameUUIDFromBytes((String.join("+", nodeId, TapiStringConstants.DSR)).getBytes(StandardCharsets.UTF_8))
1117                 .toString());
1118         int count = 1;
1119         for (NonBlockingList nbl : oorOduSwitchingPool.nonnullNonBlockingList().values()) {
1120             LOG.info("Non blocking list = {}", nbl);
1121             Map<NodeEdgePointKey, NodeEdgePoint> nepList = new HashMap<>();
1122             for (TpId tp : nbl.getTpList()) {
1123                 String tpUuidSd = String.join("+", nodeId, TapiStringConstants.E_ODU, tp.getValue());
1124                 LOG.info("EDOU TP = {}", tpUuidSd);
1125                 Uuid tpUuid = new Uuid(UUID.nameUUIDFromBytes(tpUuidSd.getBytes(StandardCharsets.UTF_8)).toString());
1126                 String tp1UuidSd = String.join("+", nodeId, TapiStringConstants.DSR, tp.getValue());
1127                 LOG.info("DSR TP = {}", tp1UuidSd);
1128                 Uuid tp1Uuid = new Uuid(UUID.nameUUIDFromBytes(tp1UuidSd.getBytes(StandardCharsets.UTF_8)).toString());
1129                 if (onepl.containsKey(new OwnedNodeEdgePointKey(tpUuid))
1130                         && onepl.containsKey(new OwnedNodeEdgePointKey(tp1Uuid))) {
1131                     NodeEdgePoint nep1 = new NodeEdgePointBuilder()
1132                         .setTopologyUuid(this.tapiTopoUuid)
1133                         .setNodeUuid(nodeUuid)
1134                         .setNodeEdgePointUuid(tp1Uuid)
1135                         .build();
1136                     NodeEdgePoint nep2 = new NodeEdgePointBuilder()
1137                         .setTopologyUuid(this.tapiTopoUuid)
1138                         .setNodeUuid(nodeUuid)
1139                         .setNodeEdgePointUuid(tpUuid)
1140                         .build();
1141                     nepList.put(nep1.key(), nep1);
1142                     nepList.put(nep2.key(), nep2);
1143                 }
1144             }
1145             // Empty random creation of mandatory fields for avoiding errors....
1146             CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
1147                 .setCostAlgorithm("Restricted Shortest Path - RSP")
1148                 .setCostName("HOP_COUNT")
1149                 .setCostValue(TapiStringConstants.COST_HOP_VALUE)
1150                 .build();
1151             LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
1152                 .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
1153                 .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
1154                 .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
1155                 .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
1156                 .setTrafficPropertyName("FIXED_LATENCY")
1157                 .build();
1158             RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
1159                 .setRiskCharacteristicName("risk characteristic")
1160                 .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
1161                 .build();
1162             NodeRuleGroup nodeRuleGroup = new NodeRuleGroupBuilder()
1163                 .setUuid(new Uuid(
1164                     UUID.nameUUIDFromBytes(("dsr node rule group " + count).getBytes(StandardCharsets.UTF_8))
1165                         .toString()))
1166                 .setRule(ruleList)
1167                 .setNodeEdgePoint(nepList)
1168                 .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
1169                 .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
1170                 .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
1171                 .build();
1172             nodeRuleGroupMap.put(nodeRuleGroup.key(), nodeRuleGroup);
1173             count++;
1174         }
1175         return nodeRuleGroupMap;
1176     }
1177
1178     private String getNodeType(XpdrNodeTypes xponderType) {
1179         switch (xponderType) {
1180             case Tpdr:
1181                 return OpenroadmNodeType.TPDR.getName();
1182             case Mpdr:
1183                 return OpenroadmNodeType.MUXPDR.getName();
1184             case Switch:
1185                 return OpenroadmNodeType.SWITCH.getName();
1186             //case Regen:
1187             //case RegenUni:
1188             default:
1189                 LOG.info("XpdrType {} not supported", xponderType);
1190                 return null;
1191         }
1192     }
1193
1194     private void mergeNodeinTopology(Map<NodeKey, Node> nodeMap) {
1195         // TODO is this merge correct? Should we just merge topology by changing the nodes map??
1196         // TODO: verify this is correct. Should we identify the context IID with the context UUID??
1197         LOG.info("Creating tapi node in TAPI topology context");
1198         // merge in datastore
1199         this.networkTransactionService.merge(
1200             LogicalDatastoreType.OPERATIONAL,
1201             InstanceIdentifier.builder(Context.class)
1202                 .augmentation(Context1.class)
1203                 .child(TopologyContext.class)
1204                 .child(Topology.class, new TopologyKey(this.tapiTopoUuid))
1205                 .build(),
1206             new TopologyBuilder().setUuid(this.tapiTopoUuid).setNode(nodeMap).build());
1207         try {
1208             this.networkTransactionService.commit().get();
1209         } catch (InterruptedException | ExecutionException e) {
1210             LOG.error("Error populating TAPI topology: ", e);
1211         }
1212         LOG.info("Node added succesfully.");
1213     }
1214
1215     private void mergeLinkinTopology(Map<LinkKey, Link> linkMap) {
1216         // TODO is this merge correct? Should we just merge topology by changing the nodes map??
1217         // TODO: verify this is correct. Should we identify the context IID with the context UUID??
1218         LOG.info("Creating tapi node in TAPI topology context");
1219         // merge in datastore
1220         this.networkTransactionService.merge(
1221             LogicalDatastoreType.OPERATIONAL,
1222             InstanceIdentifier.builder(Context.class)
1223                 .augmentation(Context1.class)
1224                 .child(TopologyContext.class)
1225                 .child(Topology.class, new TopologyKey(this.tapiTopoUuid))
1226                 .build(),
1227             new TopologyBuilder().setUuid(this.tapiTopoUuid).setLink(linkMap).build());
1228         try {
1229             this.networkTransactionService.commit().get();
1230         } catch (InterruptedException | ExecutionException e) {
1231             LOG.error("Error populating TAPI topology: ", e);
1232         }
1233         LOG.info("Roadm Link added succesfully.");
1234     }
1235
1236     private void mergeSipsinContext(Map<ServiceInterfacePointKey, ServiceInterfacePoint> sips) {
1237         // TODO is this merge correct? Should we just merge topology by changing the nodes map??
1238         // TODO: verify this is correct. Should we identify the context IID with the context UUID??
1239         try {
1240             // merge in datastore
1241             this.networkTransactionService.merge(
1242                 LogicalDatastoreType.OPERATIONAL,
1243                 InstanceIdentifier.builder(Context.class).build(),
1244                 new ContextBuilder().setServiceInterfacePoint(sips).build());
1245             this.networkTransactionService.commit().get();
1246             LOG.info("TAPI SIPs merged successfully.");
1247         } catch (InterruptedException | ExecutionException e) {
1248             LOG.error("Failed to merge TAPI Sips", e);
1249         }
1250     }
1251
1252     private void deleteLinkFromTopo(Uuid linkUuid) {
1253         try {
1254             this.networkTransactionService.delete(
1255                 LogicalDatastoreType.OPERATIONAL,
1256                 // TODO: check if this IID is correct
1257                 InstanceIdentifier.builder(Context.class)
1258                     .augmentation(Context1.class)
1259                     .child(TopologyContext.class)
1260                     .child(Topology.class, new TopologyKey(this.tapiTopoUuid))
1261                     .child(Link.class, new LinkKey(linkUuid)).build());
1262             this.networkTransactionService.commit().get();
1263             LOG.info("TAPI link deleted successfully.");
1264         } catch (InterruptedException | ExecutionException e) {
1265             LOG.error("Failed to delete TAPI link", e);
1266         }
1267     }
1268
1269     private void deleteNodeFromTopo(Uuid nodeUuid) {
1270         try {
1271             this.networkTransactionService.delete(
1272                 LogicalDatastoreType.OPERATIONAL,
1273                 // TODO: check if this IID is correct
1274                 InstanceIdentifier.builder(Context.class)
1275                     .augmentation(Context1.class)
1276                     .child(TopologyContext.class)
1277                     .child(Topology.class, new TopologyKey(this.tapiTopoUuid))
1278                     .child(Node.class, new NodeKey(nodeUuid)).build());
1279             this.networkTransactionService.commit().get();
1280             LOG.info("TAPI Node deleted successfully.");
1281         } catch (InterruptedException | ExecutionException e) {
1282             LOG.error("Failed to delete TAPI Node", e);
1283         }
1284     }
1285
1286     private void deleteSipFromTopo(Uuid sipUuid) {
1287         // TODO: check if this IID is correct
1288         try {
1289             this.networkTransactionService.delete(
1290                 LogicalDatastoreType.OPERATIONAL,
1291                 InstanceIdentifier.builder(Context.class)
1292                     .child(ServiceInterfacePoint.class, new ServiceInterfacePointKey(sipUuid))
1293                     .build());
1294             this.networkTransactionService.commit().get();
1295             LOG.info("TAPI SIP deleted successfully.");
1296         } catch (InterruptedException | ExecutionException e) {
1297             LOG.error("Failed to delete TAPI SIP", e);
1298         }
1299     }
1300
1301     private void updateConnectivityServicesState(Uuid sipUuid, String nodeId) {
1302         // TODO: check if this IID is correct
1303         ConnectivityContext connContext = null;
1304         try {
1305             Optional<ConnectivityContext> optConnContext =
1306                 this.networkTransactionService.read(
1307                         LogicalDatastoreType.OPERATIONAL,
1308                         InstanceIdentifier.builder(Context.class)
1309                             .augmentation(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121
1310                                 .Context1.class)
1311                             .child(ConnectivityContext.class)
1312                             .build())
1313                     .get();
1314             if (optConnContext.isEmpty()) {
1315                 LOG.error("Couldnt retrieve connectivity context from datastore");
1316                 return;
1317             }
1318             connContext = optConnContext.orElseThrow();
1319         } catch (InterruptedException | ExecutionException e) {
1320             LOG.error("Couldnt read connectivity context from datastore", e);
1321         }
1322         if (connContext == null) {
1323             LOG.error("Connectivity context is empty");
1324             return;
1325         }
1326         // Loop through services, check if the endpoint uuid is equal to the sip.
1327         // If so update state.
1328         Map<ConnectivityServiceKey, ConnectivityService> connServMap = connContext.getConnectivityService();
1329         Map<ConnectionKey, Connection> connMap = connContext.getConnection();
1330         if (connServMap != null) {
1331             for (ConnectivityService service : connServMap.values()) {
1332                 Map<EndPointKey, EndPoint> serviceEndPoints = service.getEndPoint();
1333                 if (serviceEndPoints.values().stream()
1334                             .anyMatch(endPoint -> endPoint.getServiceInterfacePoint().getServiceInterfacePointUuid()
1335                         .equals(sipUuid))) {
1336                     LOG.info("Service using SIP of node {} identified. Update state of service", nodeId);
1337                     updateConnectivityService(
1338                         new ConnectivityServiceBuilder(service)
1339                             .setAdministrativeState(AdministrativeState.LOCKED)
1340                             .setOperationalState(OperationalState.DISABLED)
1341                             .setLifecycleState(LifecycleState.PENDINGREMOVAL)
1342                             .build());
1343                 }
1344             }
1345         }
1346         // Update state of connections
1347         if (connMap == null) {
1348             return;
1349         }
1350         for (Connection connection:connMap.values()) {
1351             if (connection.getName().values().stream().anyMatch(name -> name.getValue().contains(nodeId))) {
1352                 updateConnection(
1353                     new ConnectionBuilder(connection)
1354                         .setLifecycleState(LifecycleState.PENDINGREMOVAL)
1355                         .setOperationalState(OperationalState.DISABLED)
1356                         .build());
1357             }
1358         }
1359     }
1360
1361     private void updateConnection(Connection updConn) {
1362         this.networkTransactionService.merge(
1363             LogicalDatastoreType.OPERATIONAL,
1364             // TODO: check if this IID is correct
1365             InstanceIdentifier.builder(Context.class)
1366                 .augmentation(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121.Context1.class)
1367                 .child(ConnectivityContext.class)
1368                 .child(Connection.class, new ConnectionKey(updConn.getUuid()))
1369                 .build(),
1370             updConn);
1371         try {
1372             this.networkTransactionService.commit().get();
1373         } catch (InterruptedException | ExecutionException e) {
1374             LOG.error("Error committing into datastore", e);
1375         }
1376     }
1377
1378     private void updateConnectivityService(ConnectivityService updService) {
1379         this.networkTransactionService.merge(
1380                 LogicalDatastoreType.OPERATIONAL,
1381                 // TODO: check if this IID is correct
1382                 InstanceIdentifier.builder(Context.class)
1383                     .augmentation(org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.connectivity.rev221121
1384                         .Context1.class)
1385                     .child(ConnectivityContext.class)
1386                     .child(ConnectivityService.class, new ConnectivityServiceKey(updService.getUuid()))
1387                     .build(),
1388                 updService);
1389         try {
1390             this.networkTransactionService.commit().get();
1391         } catch (InterruptedException | ExecutionException e) {
1392             LOG.error("Error committing into datastore", e);
1393         }
1394     }
1395
1396     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> populateNepsForRdmNode(
1397             String nodeId, Map<String, TerminationPoint1> tpMap, boolean withSip, String nepPhotonicSublayer) {
1398         // create neps for MC and and Photonic Media OTS/OMS
1399         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = new HashMap<>();
1400         for (Map.Entry<String, TerminationPoint1> entry : tpMap.entrySet()) {
1401             // Admin and oper state common for all tps
1402             // PHOTONIC MEDIA nep
1403             String nepNameValue = String.join("+", nodeId, nepPhotonicSublayer, entry.getKey());
1404             LOG.debug("PHOTO NEP = {}", nepNameValue);
1405             SupportedCepLayerProtocolQualifierInstancesBuilder sclpqiBd =
1406                 new SupportedCepLayerProtocolQualifierInstancesBuilder().setNumberOfCepInstances(Uint64.valueOf(1));
1407             switch (nepPhotonicSublayer) {
1408                 case TapiStringConstants.PHTNC_MEDIA_OMS:
1409                     sclpqiBd.setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROMS.VALUE);
1410                     break;
1411                 case TapiStringConstants.PHTNC_MEDIA_OTS:
1412                     sclpqiBd.setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE);
1413                     break;
1414                 case TapiStringConstants.MC:
1415                     sclpqiBd.setLayerProtocolQualifier(PHOTONICLAYERQUALIFIERMC.VALUE);
1416                     break;
1417                 case TapiStringConstants.OTSI_MC:
1418                     sclpqiBd.setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTSiMC.VALUE);
1419                     break;
1420                 default:
1421                     break;
1422             }
1423             List<SupportedCepLayerProtocolQualifierInstances> sclpqiList = new ArrayList<>(List.of(sclpqiBd.build()));
1424             OwnedNodeEdgePointBuilder onepBd = new OwnedNodeEdgePointBuilder();
1425             if (!nepPhotonicSublayer.equals(TapiStringConstants.MC)
1426                     && !nepPhotonicSublayer.equals(TapiStringConstants.OTSI_MC)) {
1427                 Map<Double,Double> usedFreqMap = new HashMap<>();
1428                 Map<Double,Double> availableFreqMap = new HashMap<>();
1429                 switch (entry.getValue().getTpType()) {
1430                     // Whatever is the TP and its type we consider that it is handled in a bidirectional way :
1431                     // same wavelength(s) used in both direction.
1432                     case SRGRXPP:
1433                     case SRGTXPP:
1434                     case SRGTXRXPP:
1435                         usedFreqMap = tapiFactory.getPP11UsedWavelength(
1436                             getNetworkTerminationPoint11FromDatastore(nodeId, entry.getKey()));
1437                         if (usedFreqMap == null || usedFreqMap.isEmpty()) {
1438                             availableFreqMap.put(
1439                                 GridConstant.START_EDGE_FREQUENCY * 1E09,
1440                                 GridConstant.START_EDGE_FREQUENCY * 1E09
1441                                     + GridConstant.GRANULARITY * GridConstant.EFFECTIVE_BITS * 1E06);
1442                         } else {
1443                             LOG.debug("EnteringLOOPcreateOTSiMC & MC with usedFreqMap non empty {} for Node {}, tp {}",
1444                                 usedFreqMap, nodeId, tpMap);
1445                             onepMap.putAll(populateNepsForRdmNode(nodeId,
1446                                 new HashMap<>(Map.of(entry.getKey(), entry.getValue())),
1447                                 true, TapiStringConstants.MC));
1448                             onepMap.putAll(populateNepsForRdmNode(nodeId,
1449                                 new HashMap<>(Map.of(entry.getKey(), entry.getValue())),
1450                                 true, TapiStringConstants.OTSI_MC));
1451                         }
1452                         break;
1453                     case DEGREERXTTP:
1454                     case DEGREETXTTP:
1455                     case DEGREETXRXTTP:
1456                         usedFreqMap = tapiFactory.getTTP11UsedFreqMap(
1457                             getNetworkTerminationPoint11FromDatastore(nodeId, entry.getKey()));
1458                         availableFreqMap = tapiFactory.getTTP11AvailableFreqMap(
1459                             getNetworkTerminationPoint11FromDatastore(nodeId, entry.getKey()));
1460                         break;
1461                     default:
1462                         break;
1463                 }
1464                 LOG.debug("calling add Photonic NEP spec for Roadm");
1465                 onepBd = tapiFactory.addPhotSpecToRoadmOnep(
1466                         nodeId, usedFreqMap, availableFreqMap, onepBd, nepPhotonicSublayer);
1467             }
1468             Name nepName =
1469                 new NameBuilder().setValueName(nepPhotonicSublayer + "NodeEdgePoint").setValue(nepNameValue).build();
1470             OwnedNodeEdgePoint onep = onepBd
1471                 .setUuid(new Uuid(UUID.nameUUIDFromBytes(nepNameValue.getBytes(Charset.forName("UTF-8"))).toString()))
1472                 .setLayerProtocolName(LayerProtocolName.PHOTONICMEDIA)
1473                 .setName(Map.of(nepName.key(), nepName))
1474                 .setSupportedCepLayerProtocolQualifierInstances(sclpqiList)
1475                 .setDirection(Direction.BIDIRECTIONAL)
1476                 .setLinkPortRole(PortRole.SYMMETRIC)
1477                 .setAdministrativeState(
1478                     this.tapiLink.setTapiAdminState(entry.getValue().getAdministrativeState().getName()))
1479                 .setOperationalState(
1480                     this.tapiLink.setTapiOperationalState(entry.getValue().getOperationalState().getName()))
1481                 .setLifecycleState(LifecycleState.INSTALLED)
1482                 .build();
1483             LOG.debug("ROADMNEPPopulation TapiNetworkModelServiceImpl populate NEP {} for Node {}",
1484                 onep.getName().entrySet(), nodeId);
1485             onepMap.put(onep.key(), onep);
1486         }
1487         LOG.debug("ROADMNEPPopulation FINISH for Node {}", nodeId);
1488         return onepMap;
1489     }
1490
1491     /**
1492      * Get a network termination point for nodeId and tpId.
1493      * @param nodeId String
1494      * @param tpId String
1495      * @return network termination point, null otherwise
1496      */
1497     private TerminationPoint getNetworkTerminationPointFromDatastore(String nodeId, String tpId) {
1498         InstanceIdentifier<TerminationPoint> tpIID = InstanceIdentifier.builder(Networks.class)
1499             .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
1500             .child(
1501                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
1502                     .networks.network.Node.class,
1503                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
1504                     .networks.network.NodeKey(new NodeId(nodeId)))
1505             .augmentation(Node1.class)
1506             .child(
1507                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
1508                     .networks.network.node.TerminationPoint.class,
1509                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
1510                     .networks.network.node.TerminationPointKey(new TpId(tpId)))
1511             .build();
1512         try {
1513             Optional<TerminationPoint> tpOptional =
1514                 networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, tpIID).get();
1515             if (tpOptional.isEmpty()) {
1516                 LOG.error("readMdSal: Error reading tp {} , empty list", tpIID);
1517                 return null;
1518             }
1519             LOG.debug("SUCCES getting LCP TP for NodeId {} TpId {} while creating NEP in TapiNetworkModelServiceImpl",
1520                 nodeId, tpId);
1521             LOG.debug(" The Tp in Datastore is as follows {}", tpOptional);
1522             return tpOptional.orElseThrow();
1523         } catch (ExecutionException | InterruptedException e) {
1524             LOG.warn("Exception while getting termination {} for node id {} point from {} topology",
1525                     tpId, nodeId, NetworkUtils.OVERLAY_NETWORK_ID, e);
1526             return null;
1527         }
1528     }
1529
1530     /**
1531      * Get a network termination point with Common TerminationPoint1 augmentation for nodeId and tpId.
1532      * @param nodeId String
1533      * @param tpId String
1534      * @return network termination point, null otherwise
1535      */
1536     private TerminationPoint1 getNetworkTerminationPoint1FromDatastore(String nodeId, String tpId) {
1537         InstanceIdentifier<TerminationPoint1> tpIID = InstanceIdentifier.builder(Networks.class)
1538             .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
1539             .child(
1540                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
1541                     .networks.network.Node.class,
1542                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
1543                     .networks.network.NodeKey(new NodeId(nodeId)))
1544             .augmentation(Node1.class)
1545             .child(
1546                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
1547                     .networks.network.node.TerminationPoint.class,
1548                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
1549                     .networks.network.node.TerminationPointKey(new TpId(tpId)))
1550             .augmentation(org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526
1551                 .TerminationPoint1.class)
1552             .build();
1553         try {
1554             Optional<TerminationPoint1> tpOptional =
1555                 networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, tpIID).get();
1556             if (tpOptional.isEmpty()) {
1557                 LOG.error("readMdSal: Error reading tp {} , empty list",tpIID);
1558                 return null;
1559             }
1560             LOG.debug("SUCCES getting LCP TP1 for NodeId {} TpId {} while creating NEP in TapiNetworkModelServiceImpl",
1561                 nodeId, tpId);
1562             LOG.debug(" The Tp in Datastore is as follows {}", tpOptional);
1563             return tpOptional.orElseThrow();
1564         } catch (ExecutionException | InterruptedException e) {
1565             LOG.warn("Exception while getting termination {} for node id {} point from {} topology",
1566                     tpId, nodeId, NetworkUtils.OVERLAY_NETWORK_ID, e);
1567             return null;
1568         }
1569     }
1570
1571     private org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526
1572             .TerminationPoint1 getNetworkTerminationPoint11FromDatastore(String nodeId, String tpId) {
1573         InstanceIdentifier<org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526
1574                 .TerminationPoint1> tpIID = InstanceIdentifier.builder(Networks.class)
1575             .child(Network.class, new NetworkKey(new NetworkId(NetworkUtils.OVERLAY_NETWORK_ID)))
1576             .child(
1577                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
1578                     .networks.network.Node.class,
1579                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.rev180226
1580                     .networks.network.NodeKey(new NodeId(nodeId)))
1581             .augmentation(Node1.class)
1582             .child(
1583                 org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
1584                     .networks.network.node.TerminationPoint.class,
1585                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
1586                     .networks.network.node.TerminationPointKey(new TpId(tpId)))
1587             .augmentation(
1588                 org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1.class)
1589             .build();
1590         try {
1591             Optional<org.opendaylight.yang.gen.v1.http.org.openroadm.network.topology.rev230526.TerminationPoint1>
1592                 tpOptional = networkTransactionService.read(LogicalDatastoreType.CONFIGURATION, tpIID).get();
1593             if (tpOptional.isEmpty()) {
1594                 LOG.error("readMdSal: Error reading tp {} , empty list", tpIID);
1595                 return null;
1596             }
1597             LOG.debug("SUCCESS getting LCP TP11 for NodeId {} TpId {} while creating NEP in TapiNetworkModelServiceImpl"
1598                 + " The Tp in Datastore is as follows {}", nodeId, tpId, tpOptional);
1599             return tpOptional.orElseThrow();
1600         } catch (ExecutionException | InterruptedException e) {
1601             LOG.warn("Exception while getting termination {} for node id {} point from {} topology",
1602                     tpId, nodeId, NetworkUtils.OVERLAY_NETWORK_ID, e);
1603             return null;
1604         }
1605     }
1606
1607 }