tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/TapiNetworkUtilsImpl.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 com.google.common.util.concurrent.ListenableFuture;
  11 import java.nio.charset.Charset;
  12 import java.util.ArrayList;
  13 import java.util.HashMap;
  14 import java.util.List;
  15 import java.util.Map;
  16 import java.util.Optional;
  17 import java.util.UUID;
  18 import java.util.concurrent.ExecutionException;
  19 import org.opendaylight.mdsal.common.api.LogicalDatastoreType;
  20 import org.opendaylight.transportpce.common.network.NetworkTransactionService;
  21 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.DeleteTapiLinkInput;
  22 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.DeleteTapiLinkOutput;
  23 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.DeleteTapiLinkOutputBuilder;
  24 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.InitRoadmRoadmTapiLinkInput;
  25 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.InitRoadmRoadmTapiLinkOutput;
  26 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.InitRoadmRoadmTapiLinkOutputBuilder;
  27 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.InitXpdrRdmTapiLinkInput;
  28 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.InitXpdrRdmTapiLinkOutput;
  29 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.InitXpdrRdmTapiLinkOutputBuilder;
  30 import org.opendaylight.yang.gen.v1.http.org.opendaylight.transportpce.tapinetworkutils.rev210408.TransportpceTapinetworkutilsService;
  31 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.AdministrativeState;
  32 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.CapacityUnit;
  33 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Context;
  34 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.ForwardingDirection;
  35 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LayerProtocolName;
  36 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.LifecycleState;
  37 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.OperationalState;
  38 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.Uuid;
  39 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.TotalSizeBuilder;
  40 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.pac.AvailableCapacityBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.capacity.pac.TotalPotentialCapacityBuilder;
  42 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.Name;
  43 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev181210.global._class.NameBuilder;
  44 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.Context1;
  45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.ProtectionType;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.RestorationPolicy;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.context.TopologyContext;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.link.NodeEdgePoint;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.link.NodeEdgePointBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.link.NodeEdgePointKey;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.link.ResilienceTypeBuilder;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePoint;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.node.OwnedNodeEdgePointKey;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.risk.parameter.pac.RiskCharacteristic;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.risk.parameter.pac.RiskCharacteristicBuilder;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Link;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.LinkBuilder;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.LinkKey;
  59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.Node;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.NodeKey;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.Topology;
  62 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.TopologyBuilder;
  63 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.topology.context.TopologyKey;
  64 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.transfer.cost.pac.CostCharacteristic;
  65 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.transfer.cost.pac.CostCharacteristicBuilder;
  66 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.transfer.timing.pac.LatencyCharacteristic;
  67 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.transfer.timing.pac.LatencyCharacteristicBuilder;
  68 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.validation.pac.ValidationMechanism;
  69 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev181210.validation.pac.ValidationMechanismBuilder;
  70 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  71 import org.opendaylight.yangtools.yang.common.RpcError;
  72 import org.opendaylight.yangtools.yang.common.RpcResult;
  73 import org.opendaylight.yangtools.yang.common.RpcResultBuilder;
  74 import org.opendaylight.yangtools.yang.common.Uint64;
  75 import org.slf4j.Logger;
  76 import org.slf4j.LoggerFactory;
  77
  78 public class TapiNetworkUtilsImpl implements TransportpceTapinetworkutilsService {
  79
  80     private static final Logger LOG = LoggerFactory.getLogger(TapiNetworkUtilsImpl.class);
  81     private static final String PHTNC_MEDIA = "PHOTONIC_MEDIA";
  82     private static final String OTSI = "OTSi";
  83     private final Uuid tapiTopoUuid = new Uuid(UUID.nameUUIDFromBytes(TopologyUtils.T0_FULL_MULTILAYER
  84             .getBytes(Charset.forName("UTF-8"))).toString());
  85     private final NetworkTransactionService networkTransactionService;
  86
  87     public TapiNetworkUtilsImpl(NetworkTransactionService networkTransactionService) {
  88         this.networkTransactionService = networkTransactionService;
  89     }
  90
  91     @Override
  92     public ListenableFuture<RpcResult<InitRoadmRoadmTapiLinkOutput>> initRoadmRoadmTapiLink(
  93             InitRoadmRoadmTapiLinkInput input) {
  94         // TODO --> need to check if the nodes and neps exist in the topology
  95         String sourceNode = input.getRdmANode();
  96         String sourceTp = input.getDegATp();
  97         String destNode = input.getRdmZNode();
  98         String destTp = input.getDegZTp();
  99         String linkId = String.join("-", sourceNode, sourceTp.split("-")[0], sourceTp)
 100             + "to" + String.join("-", destNode, destTp.split("-")[0], destTp);
 101         Link link = createTapiLink(sourceNode, sourceTp, destNode, destTp, linkId, "OMS link name", PHTNC_MEDIA);
 102         InitRoadmRoadmTapiLinkOutputBuilder output = new InitRoadmRoadmTapiLinkOutputBuilder();
 103         if (link == null) {
 104             LOG.error("Error creating link object");
 105             return RpcResultBuilder.<InitRoadmRoadmTapiLinkOutput>failed().withError(RpcError.ErrorType.RPC,
 106                 "Failed to create link in topology").buildFuture();
 107         }
 108         if (putLinkInTopology(link)) {
 109             output = new InitRoadmRoadmTapiLinkOutputBuilder()
 110                 .setResult("Link created in tapi topology. Link-uuid = " + link.getUuid());
 111         }
 112         return RpcResultBuilder.success(output.build()).buildFuture();
 113     }
 114
 115     @Override
 116     public ListenableFuture<RpcResult<InitXpdrRdmTapiLinkOutput>> initXpdrRdmTapiLink(InitXpdrRdmTapiLinkInput input) {
 117         // TODO --> need to check if the nodes and neps exist in the topology
 118         String destNode = input.getRdmNode();
 119         String destTp = input.getAddDropTp();
 120         String sourceNode = input.getXpdrNode();
 121         String sourceTp = input.getNetworkTp();
 122         String linkId = String.join("-", sourceNode, sourceTp)
 123             + "to" + String.join("-", destNode, destTp.split("-")[0], destTp);
 124         Link link = createTapiLink(sourceNode, sourceTp, destNode, destTp, linkId, "XPDR-RDM link name", OTSI);
 125         InitXpdrRdmTapiLinkOutputBuilder output = new InitXpdrRdmTapiLinkOutputBuilder();
 126         if (link == null) {
 127             LOG.error("Error creating link object");
 128             return RpcResultBuilder.<InitXpdrRdmTapiLinkOutput>failed().withError(RpcError.ErrorType.RPC,
 129                 "Failed to create link in topology").buildFuture();
 130         }
 131         if (putLinkInTopology(link)) {
 132             output = new InitXpdrRdmTapiLinkOutputBuilder()
 133                 .setResult("Link created in tapi topology. Link-uuid = " + link.getUuid());
 134         }
 135         return RpcResultBuilder.success(output.build()).buildFuture();
 136     }
 137
 138     @Override
 139     public ListenableFuture<RpcResult<DeleteTapiLinkOutput>> deleteTapiLink(DeleteTapiLinkInput input) {
 140         // TODO: check if this IID is correct
 141         // TODO --> need to check if the link exists in the topology
 142         try {
 143             InstanceIdentifier<Link> linkIID = InstanceIdentifier.builder(Context.class)
 144                     .augmentation(Context1.class).child(TopologyContext.class).child(Topology.class,
 145                             new TopologyKey(tapiTopoUuid)).child(Link.class, new LinkKey(input.getUuid())).build();
 146             this.networkTransactionService.delete(LogicalDatastoreType.OPERATIONAL, linkIID);
 147             this.networkTransactionService.commit().get();
 148             LOG.info("TAPI link deleted successfully.");
 149             return RpcResultBuilder.success(new DeleteTapiLinkOutputBuilder()
 150                 .setResult("Link successfully deleted from tapi topology").build()).buildFuture();
 151         } catch (InterruptedException | ExecutionException e) {
 152             LOG.error("Failed to delete TAPI link", e);
 153             return RpcResultBuilder.<DeleteTapiLinkOutput>failed().withError(RpcError.ErrorType.RPC,
 154                 "Failed to delete link from topology").buildFuture();
 155         }
 156     }
 157
 158     private Link createTapiLink(String sourceNode, String sourceTp, String destNode, String destTp, String linkId,
 159                                 String valueName, String sourceNodeQual) {
 160         Map<NodeEdgePointKey, NodeEdgePoint> nepList = new HashMap<>();
 161         Uuid sourceUuidNode = new Uuid(UUID.nameUUIDFromBytes((String.join("+", sourceNode,
 162             sourceNodeQual)).getBytes(Charset.forName("UTF-8"))).toString());
 163         Uuid sourceUuidTp = new Uuid(UUID.nameUUIDFromBytes((String.join("+", sourceNode, PHTNC_MEDIA,
 164             sourceTp)).getBytes(Charset.forName("UTF-8"))).toString());
 165         Uuid destUuidNode = new Uuid(UUID.nameUUIDFromBytes((String.join("+", destNode,
 166             PHTNC_MEDIA)).getBytes(Charset.forName("UTF-8"))).toString());
 167         Uuid destUuidTp = new Uuid(UUID.nameUUIDFromBytes((String.join("+", destNode, PHTNC_MEDIA,
 168             destTp)).getBytes(Charset.forName("UTF-8"))).toString());
 169         if (!(nodeExists(sourceUuidNode) && nodeExists(destUuidNode)
 170                 && nepExists(sourceUuidTp, sourceUuidNode) && nepExists(destUuidTp, destUuidNode))) {
 171             LOG.error("Verify the input data. No link can be created, "
 172                 + "as either the node or the tp doesnt exist in the TAPI topology");
 173             return null;
 174         }
 175
 176         NodeEdgePoint sourceNep = new NodeEdgePointBuilder()
 177             .setTopologyUuid(this.tapiTopoUuid)
 178             .setNodeUuid(sourceUuidNode)
 179             .setNodeEdgePointUuid(sourceUuidTp)
 180             .build();
 181         nepList.put(sourceNep.key(), sourceNep);
 182         NodeEdgePoint destNep = new NodeEdgePointBuilder()
 183             .setTopologyUuid(this.tapiTopoUuid)
 184             .setNodeUuid(destUuidNode)
 185             .setNodeEdgePointUuid(destUuidTp)
 186             .build();
 187         nepList.put(destNep.key(), destNep);
 188         OperationalState sourceOperState = getOperState(sourceUuidTp, sourceUuidNode);
 189         OperationalState destOperState = getOperState(destUuidTp, destUuidNode);
 190         if (sourceOperState == null || destOperState == null) {
 191             LOG.error("No link can be created, as the operational state was not found in the TAPI topology");
 192             return null;
 193         }
 194         AdministrativeState sourceAdminState = getAdminState(sourceUuidTp, sourceUuidNode);
 195         AdministrativeState destAdminState = getAdminState(destUuidTp, destUuidNode);
 196         if (sourceAdminState == null || destAdminState == null) {
 197             LOG.error("No link can be created, as the administrative state was not found in the TAPI topology");
 198             return null;
 199         }
 200         OperationalState operState = (OperationalState.ENABLED.equals(sourceOperState)
 201                 && OperationalState.ENABLED.equals(destOperState))
 202                 ? OperationalState.ENABLED : OperationalState.DISABLED;
 203         AdministrativeState adminState = (AdministrativeState.UNLOCKED.equals(sourceAdminState)
 204                 && AdministrativeState.UNLOCKED.equals(destAdminState))
 205                 ? AdministrativeState.UNLOCKED : AdministrativeState.LOCKED;
 206         Name linkName = new NameBuilder().setValueName(valueName)
 207             .setValue(linkId)
 208             .build();
 209         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 210             .setCostAlgorithm("Restricted Shortest Path - RSP")
 211             .setCostName("HOP_COUNT")
 212             .setCostValue("12345678")
 213             .build();
 214         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 215             .setFixedLatencyCharacteristic("12345678")
 216             .setQueingLatencyCharacteristic("12345678")
 217             .setJitterCharacteristic("12345678")
 218             .setWanderCharacteristic("12345678")
 219             .setTrafficPropertyName("FIXED_LATENCY")
 220             .build();
 221         RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
 222             .setRiskCharacteristicName("risk characteristic")
 223             .setRiskIdentifierList(List.of("risk identifier1", "risk identifier2"))
 224             .build();
 225         ValidationMechanism validationMechanism = new ValidationMechanismBuilder()
 226             .setValidationMechanism("validation mechanism")
 227             .setValidationRobustness("validation robustness")
 228             .setLayerProtocolAdjacencyValidated("layer protocol adjacency")
 229             .build();
 230         return new LinkBuilder()
 231             .setUuid(new Uuid(
 232                 UUID.nameUUIDFromBytes(linkId.getBytes(Charset.forName("UTF-8")))
 233                     .toString()))
 234             .setName(Map.of(linkName.key(), linkName))
 235             .setLayerProtocolName(List.of(LayerProtocolName.PHOTONICMEDIA))
 236             .setNodeEdgePoint(nepList)
 237             .setDirection(ForwardingDirection.BIDIRECTIONAL)
 238             .setTransitionedLayerProtocolName(new ArrayList<>())
 239             .setResilienceType(new ResilienceTypeBuilder().setProtectionType(ProtectionType.NOPROTECTON)
 240                 .setRestorationPolicy(RestorationPolicy.NA)
 241                 .build())
 242             .setAdministrativeState(adminState)
 243             .setOperationalState(operState)
 244             .setLifecycleState(LifecycleState.INSTALLED)
 245             .setTotalPotentialCapacity(new TotalPotentialCapacityBuilder().setTotalSize(
 246                 new TotalSizeBuilder().setUnit(CapacityUnit.GBPS)
 247                     .setValue(Uint64.valueOf(100)).build()).build())
 248             .setAvailableCapacity(new AvailableCapacityBuilder().setTotalSize(
 249                 new TotalSizeBuilder().setUnit(CapacityUnit.MBPS)
 250                     .setValue(Uint64.valueOf(100)).build())
 251                 .build())
 252             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 253             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 254             .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
 255             .setErrorCharacteristic("error")
 256             .setLossCharacteristic("loss")
 257             .setRepeatDeliveryCharacteristic("repeat delivery")
 258             .setDeliveryOrderCharacteristic("delivery order")
 259             .setUnavailableTimeCharacteristic("unavailable time")
 260             .setServerIntegrityProcessCharacteristic("server integrity process")
 261             .setValidationMechanism(Map.of(validationMechanism.key(), validationMechanism))
 262             .build();
 263     }
 264
 265     private boolean nepExists(Uuid nepUuid, Uuid nodeUuid) {
 266         LOG.info("Checking if nep with uuid {} existis in tapi topology", nepUuid);
 267         try {
 268             InstanceIdentifier<OwnedNodeEdgePoint> onepIID = InstanceIdentifier.builder(Context.class)
 269                 .augmentation(Context1.class).child(TopologyContext.class)
 270                 .child(Topology.class, new TopologyKey(tapiTopoUuid)).child(Node.class, new NodeKey(nodeUuid))
 271                 .child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nepUuid))
 272                 .build();
 273             Optional<OwnedNodeEdgePoint> optionalOnep = this.networkTransactionService.read(
 274                 LogicalDatastoreType.OPERATIONAL, onepIID).get();
 275             if (!optionalOnep.isPresent()) {
 276                 LOG.error("ONEP is not present in datastore");
 277                 return false;
 278             }
 279             return true;
 280         } catch (InterruptedException | ExecutionException e) {
 281             LOG.error("Couldnt retrieve nep from datastore");
 282             return false;
 283         }
 284     }
 285
 286     private boolean nodeExists(Uuid nodeUuid) {
 287         LOG.info("Checking if node with uuid {} existis in tapi topology", nodeUuid);
 288         try {
 289             InstanceIdentifier<Node> nodeIID = InstanceIdentifier.builder(Context.class)
 290                 .augmentation(Context1.class).child(TopologyContext.class)
 291                 .child(Topology.class, new TopologyKey(tapiTopoUuid)).child(Node.class, new NodeKey(nodeUuid))
 292                 .build();
 293             Optional<Node> optionalNode = this.networkTransactionService.read(
 294                 LogicalDatastoreType.OPERATIONAL, nodeIID).get();
 295             if (!optionalNode.isPresent()) {
 296                 LOG.error("Node is not present in datastore");
 297                 return false;
 298             }
 299             return true;
 300         } catch (InterruptedException | ExecutionException e) {
 301             LOG.error("Couldnt retrieve nep from datastore");
 302             return false;
 303         }
 304     }
 305
 306     private OperationalState getOperState(Uuid nepUuid, Uuid nodeUuid) {
 307         try {
 308             InstanceIdentifier<OwnedNodeEdgePoint> onepIID = InstanceIdentifier.builder(Context.class)
 309                     .augmentation(Context1.class).child(TopologyContext.class)
 310                     .child(Topology.class, new TopologyKey(tapiTopoUuid)).child(Node.class, new NodeKey(nodeUuid))
 311                     .child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nepUuid))
 312                     .build();
 313             Optional<OwnedNodeEdgePoint> optionalOnep = this.networkTransactionService.read(
 314                     LogicalDatastoreType.OPERATIONAL, onepIID).get();
 315             if (optionalOnep.isPresent()) {
 316                 return optionalOnep.get().getOperationalState();
 317             }
 318             return null;
 319         } catch (InterruptedException | ExecutionException e) {
 320             LOG.error("Couldnt retrieve nep from datastore");
 321             return null;
 322         }
 323     }
 324
 325     private AdministrativeState getAdminState(Uuid nepUuid, Uuid nodeUuid) {
 326         try {
 327             InstanceIdentifier<OwnedNodeEdgePoint> onepIID = InstanceIdentifier.builder(Context.class)
 328                     .augmentation(Context1.class).child(TopologyContext.class)
 329                     .child(Topology.class, new TopologyKey(tapiTopoUuid)).child(Node.class, new NodeKey(nodeUuid))
 330                     .child(OwnedNodeEdgePoint.class, new OwnedNodeEdgePointKey(nepUuid))
 331                     .build();
 332             Optional<OwnedNodeEdgePoint> optionalOnep = this.networkTransactionService.read(
 333                     LogicalDatastoreType.OPERATIONAL, onepIID).get();
 334             if (optionalOnep.isPresent()) {
 335                 return optionalOnep.get().getAdministrativeState();
 336             }
 337             return null;
 338         } catch (InterruptedException | ExecutionException e) {
 339             LOG.error("Couldnt retrieve nep from datastore");
 340             return null;
 341         }
 342     }
 343
 344     private boolean putLinkInTopology(Link tapiLink) {
 345         // TODO is this merge correct? Should we just merge topology by changing the nodes map??
 346         // TODO: verify this is correct. Should we identify the context IID with the context UUID??
 347         LOG.info("Creating tapi node in TAPI topology context");
 348         InstanceIdentifier<Topology> topoIID = InstanceIdentifier.builder(Context.class)
 349             .augmentation(Context1.class).child(TopologyContext.class)
 350             .child(Topology.class, new TopologyKey(tapiTopoUuid))
 351             .build();
 352
 353         Topology topology = new TopologyBuilder().setUuid(tapiTopoUuid)
 354             .setLink(Map.of(tapiLink.key(), tapiLink)).build();
 355
 356         // merge in datastore
 357         this.networkTransactionService.merge(LogicalDatastoreType.OPERATIONAL, topoIID,
 358             topology);
 359         try {
 360             this.networkTransactionService.commit().get();
 361
 362         } catch (InterruptedException | ExecutionException e) {
 363             LOG.error("Error populating TAPI topology: ", e);
 364             return false;
 365         }
 366         LOG.info("TAPI Link added succesfully.");
 367         return true;
 368     }
 369 }