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