tapi/src/main/java/org/opendaylight/transportpce/tapi/topology/ConvertORTopoToTapiTopo.java

   1 /*
   2  * Copyright © 2019 Orange, 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.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.HashMap;
  14 import java.util.Iterator;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Map.Entry;
  18 import java.util.Set;
  19 import java.util.UUID;
  20 import java.util.stream.Collectors;
  21 import org.opendaylight.transportpce.tapi.TapiStringConstants;
  22 import org.opendaylight.transportpce.tapi.utils.TapiLink;
  23 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.network.rev230526.Link1;
  24 import org.opendaylight.yang.gen.v1.http.org.openroadm.common.state.types.rev191129.State;
  25 import org.opendaylight.yang.gen.v1.http.org.openroadm.equipment.states.types.rev191129.AdminStates;
  26 import org.opendaylight.yang.gen.v1.http.org.openroadm.network.types.rev230526.OpenroadmNodeType;
  27 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.AdministrativeState;
  28 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Direction;
  29 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.ForwardingDirection;
  30 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LayerProtocolName;
  31 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.LifecycleState;
  32 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.OperationalState;
  33 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.PortRole;
  34 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.Uuid;
  35 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.Name;
  36 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.global._class.NameKey;
  38 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePoint;
  39 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.common.rev221121.tapi.context.ServiceInterfacePointKey;
  40 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.photonic.media.rev221121.PHOTONICLAYERQUALIFIEROTS;
  41 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.link.NodeEdgePoint;
  42 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.link.NodeEdgePointBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.link.NodeEdgePointKey;
  44 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroup;
  45 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.NodeRuleGroupKey;
  46 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePoint;
  47 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointBuilder;
  48 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.OwnedNodeEdgePointKey;
  49 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.RiskParameterPacBuilder;
  50 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.node.edge.point.SupportedCepLayerProtocolQualifierInstancesBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristic;
  52 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.risk.parameter.pac.RiskCharacteristicBuilder;
  53 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Link;
  54 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkBuilder;
  55 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.LinkKey;
  56 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeBuilder;
  57 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.NodeKey;
  58 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristic;
  59 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.cost.pac.CostCharacteristicBuilder;
  60 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristic;
  61 import org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.transfer.timing.pac.LatencyCharacteristicBuilder;
  62 import org.opendaylight.yangtools.yang.common.Uint64;
  63 import org.slf4j.Logger;
  64 import org.slf4j.LoggerFactory;
  65
  66
  67 public class ConvertORTopoToTapiTopo {
  68
  69     private static final Logger LOG = LoggerFactory.getLogger(ConvertORTopoToTapiTopo.class);
  70     private Uuid tapiTopoUuid;
  71     private Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
  72         tapiNodes;
  73     private Map<LinkKey, Link> tapiLinks;
  74     private Map<ServiceInterfacePointKey, ServiceInterfacePoint> tapiSips;
  75     private final TapiLink tapiLink;
  76
  77
  78     public ConvertORTopoToTapiTopo(Uuid tapiTopoUuid, TapiLink tapiLink) {
  79         this.tapiTopoUuid = tapiTopoUuid;
  80         this.tapiNodes = new HashMap<>();
  81         this.tapiLinks = new HashMap<>();
  82         this.tapiSips = new HashMap<>();
  83         this.tapiLink = tapiLink;
  84     }
  85
  86     public void convertLinks(Map<
  87             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
  88                 .networks.network.LinkKey,
  89             org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
  90                 .networks.network.Link> otnLinkMap) {
  91         List<org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
  92                 .networks.network.Link> otnLinkList = new ArrayList<>(otnLinkMap.values());
  93         Collections.sort(otnLinkList, (l1, l2) -> l1.getLinkId().getValue().compareTo(l2.getLinkId().getValue()));
  94         List<String> linksToNotConvert = new ArrayList<>();
  95         LOG.info("creation of {} otn links", otnLinkMap.size() / 2);
  96         for (var otnlink : otnLinkList) {
  97             String otnlinkId = otnlink.getLinkId().getValue();
  98             if (linksToNotConvert.contains(otnlinkId)) {
  99                 continue;
 100             }
 101             var otnlinkAug = otnlink.augmentation(Link1.class);
 102             var oppositeLink = otnLinkMap.get(
 103                 new org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.network.topology.rev180226
 104                     .networks.network.LinkKey(otnlinkAug.getOppositeLink()));
 105             AdminStates oppLnkAdmState = null;
 106             State oppLnkOpState = null;
 107             String oppositeLinkId = null;
 108             if (oppositeLink != null) {
 109                 var oppositeLinkAug = oppositeLink.augmentation(Link1.class);
 110                 oppLnkAdmState = oppositeLinkAug.getAdministrativeState();
 111                 oppLnkOpState = oppositeLinkAug.getOperationalState();
 112                 oppositeLinkId = oppositeLink.getLinkId().getValue();
 113             }
 114             // TODO: Handle not only OTU4 but also other cases
 115             String prefix = otnlinkId.split("-")[0];
 116             String tpsQual = prefix.equals("OTU4") ? TapiStringConstants.I_OTSI : TapiStringConstants.E_ODU;
 117             LayerProtocolName layerProtocolName =
 118                 prefix.equals("OTU4") ? LayerProtocolName.PHOTONICMEDIA : LayerProtocolName.ODU;
 119             var otnlinkSrc = otnlink.getSource();
 120             var otnlinkDst = otnlink.getDestination();
 121             Link tapLink = this.tapiLink.createTapiLink(
 122                 otnlinkSrc.getSourceNode().getValue(),
 123                 otnlinkSrc.getSourceTp().getValue(),
 124                 otnlinkDst.getDestNode().getValue(),
 125                 otnlinkDst.getDestTp().getValue(),
 126                 TapiStringConstants.OTN_XPDR_XPDR_LINK,
 127                 // nodesQual, nodesQual,
 128                 TapiStringConstants.XPDR, TapiStringConstants.XPDR,
 129                 tpsQual, tpsQual,
 130                 otnlinkAug.getAdministrativeState() == null || oppLnkAdmState == null ? null
 131                     : this.tapiLink.setTapiAdminState(
 132                         otnlinkAug.getAdministrativeState(), oppLnkAdmState).getName(),
 133                 otnlinkAug.getOperationalState() == null || oppLnkOpState == null ? null
 134                     : this.tapiLink.setTapiOperationalState(
 135                         otnlinkAug.getOperationalState(), oppLnkOpState).getName(),
 136                 Set.of(layerProtocolName),
 137                 Set.of(layerProtocolName.getName()),
 138                 this.tapiTopoUuid);
 139             linksToNotConvert.add(oppositeLinkId);
 140             tapiLinks.put(tapLink.key(), tapLink);
 141             LOG.debug("Links converted are as follow  {}", tapiLinks);
 142         }
 143     }
 144
 145     public void convertRoadmInfrastructure() {
 146         LOG.info("abstraction of the ROADM infrastructure towards a photonic node");
 147         Uuid nodeUuid = new Uuid(UUID.nameUUIDFromBytes(
 148                     TapiStringConstants.RDM_INFRA.getBytes(Charset.forName("UTF-8")))
 149                 .toString());
 150         Name nodeName =
 151             new NameBuilder().setValueName("otsi node name").setValue(TapiStringConstants.RDM_INFRA).build();
 152         Name nodeName2 =
 153             new NameBuilder().setValueName("roadm node name").setValue(TapiStringConstants.RDM_INFRA).build();
 154         Name nameNodeType =
 155             new NameBuilder().setValueName("Node Type").setValue(OpenroadmNodeType.ROADM.getName()).build();
 156         Set<LayerProtocolName> nodeLayerProtocols = Set.of(LayerProtocolName.PHOTONICMEDIA);
 157         //At that stage, there is no Roadm in the tapiPhotonicNodes Map / only the transponders
 158         Map<String, String> photonicNepUuisMap =
 159             convertListNodeWithListNepToMapForUuidAndName(pruneTapiPhotonicNodes());
 160         // nep creation for rdm infra abstraction node
 161         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = createNepForRdmNode(photonicNepUuisMap.size());
 162         // node rule group creation
 163         var tapiFactory = new ConvertORToTapiTopology(this.tapiTopoUuid);
 164         Map<NodeRuleGroupKey, NodeRuleGroup> nodeRuleGroupMap
 165             = tapiFactory.createAllNodeRuleGroupForRdmNode("T0ML", nodeUuid, null, onepMap.values());
 166         // Empty random creation of mandatory fields for avoiding errors....
 167         CostCharacteristic costCharacteristic = new CostCharacteristicBuilder()
 168             .setCostAlgorithm("Restricted Shortest Path - RSP")
 169             .setCostName("HOP_COUNT")
 170             .setCostValue(TapiStringConstants.COST_HOP_VALUE)
 171             .build();
 172         LatencyCharacteristic latencyCharacteristic = new LatencyCharacteristicBuilder()
 173             .setFixedLatencyCharacteristic(TapiStringConstants.FIXED_LATENCY_VALUE)
 174             .setQueuingLatencyCharacteristic(TapiStringConstants.QUEING_LATENCY_VALUE)
 175             .setJitterCharacteristic(TapiStringConstants.JITTER_VALUE)
 176             .setWanderCharacteristic(TapiStringConstants.WANDER_VALUE)
 177             .setTrafficPropertyName("FIXED_LATENCY")
 178             .build();
 179         RiskCharacteristic riskCharacteristic = new RiskCharacteristicBuilder()
 180             .setRiskCharacteristicName("risk characteristic")
 181             .setRiskIdentifierList(Set.of("risk identifier1", "risk identifier2"))
 182             .build();
 183         // build RDM infra node abstraction
 184         var rdmNode = new NodeBuilder()
 185             .setUuid(nodeUuid)
 186             .setName(Map.of(nodeName.key(), nodeName, nodeName2.key(), nodeName2, nameNodeType.key(), nameNodeType))
 187             .setLayerProtocolName(nodeLayerProtocols)
 188             .setAdministrativeState(AdministrativeState.UNLOCKED)
 189             .setOperationalState(OperationalState.ENABLED)
 190             .setLifecycleState(LifecycleState.INSTALLED)
 191             .setOwnedNodeEdgePoint(onepMap)
 192             .setNodeRuleGroup(nodeRuleGroupMap)
 193             .setInterRuleGroup(
 194                 tapiFactory.createInterRuleGroupForRdmNode("T0ML", nodeUuid, null,
 195                     nodeRuleGroupMap.entrySet().stream().map(e -> e.getKey()).collect(Collectors.toList())))
 196             .setCostCharacteristic(Map.of(costCharacteristic.key(), costCharacteristic))
 197             .setLatencyCharacteristic(Map.of(latencyCharacteristic.key(), latencyCharacteristic))
 198             .setRiskParameterPac(
 199                 new RiskParameterPacBuilder()
 200                     .setRiskCharacteristic(Map.of(riskCharacteristic.key(), riskCharacteristic))
 201                     .build())
 202             .build();
 203         tapiNodes.put(rdmNode.key(), rdmNode);
 204     // OTS link creation between photonic nodes and RDM infra abstraction node :
 205       //onepMap is a list of nep which Uuid is formed from THE ROADM node name, "nep" and an integer (order of the nep)
 206       // It has absolutely no relationship with the real ROADM infrastructure (SRG ports)
 207       //rdmInfraNepUuisMap is a Map <ROADMnodeUuuid--NepUuid; ROADMnodeName--nepName> built from onepMap
 208       //photonicNepUuisMap is a Map <TSPnodeUuuid--eNepUuid; TSPnodeName--nepName> built from TapiPhotonicNode
 209         Map<String, String> rdmInfraNepUuisMap = convertListNodeWithListNepToMapForUuidAndName(List.of(rdmNode));
 210         if (photonicNepUuisMap.size() == rdmInfraNepUuisMap.size()) {
 211             //Tapi OtsLinks are created between Neps corresponding to the eNEPs of transponders (existing network ports)
 212             //and Generic NEPS with abstracted names created in the ROADM infrastructure corresponding to tps mirroring
 213             //transponders NETWORK PORTs. There is a simplification here considering that any network port of
 214             //transponders will have a mirroring SRG client port in the ROADM infrastructure.
 215             // TODO: Do not understand that we build OTS link without checking that existing transponder ports
 216             //are effectively connected. Need some consolidation
 217             createTapiOtsLinks(photonicNepUuisMap, rdmInfraNepUuisMap);
 218         } else {
 219             LOG.warn("Unable to build OTS links between photonics nodes and RDM infrasctructure abstraction");
 220         }
 221     }
 222
 223     private List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 224             pruneTapiPhotonicNodes() {
 225         List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 226             prunedTapiPhotonicNodes = new ArrayList<>();
 227         for (org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node node :
 228                 this.tapiNodes.values().stream()
 229                     .filter(n -> n.getLayerProtocolName().contains(LayerProtocolName.PHOTONICMEDIA))
 230                     .collect(Collectors.toList())) {
 231             Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepM = new HashMap<>();
 232             for (Map.Entry<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> entry : node.getOwnedNodeEdgePoint().entrySet()) {
 233                 if (entry.getValue().getName().values().stream()
 234                     .filter(name -> name.getValueName().equals("eNodeEdgePoint")).count() > 0) {
 235                     onepM.put(entry.getKey(), entry.getValue());
 236                 }
 237             }
 238             prunedTapiPhotonicNodes.add(new NodeBuilder(node).setOwnedNodeEdgePoint(onepM).build());
 239         }
 240         return prunedTapiPhotonicNodes;
 241     }
 242
 243     private Map<String, String> convertListNodeWithListNepToMapForUuidAndName(
 244             List<org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> nodes) {
 245         Map<String, String> uuidNameMap = new HashMap<>();
 246         for (var node : nodes) {
 247             String nodeName = node.getName().get(new NameKey("otsi node name")).getValue();
 248             String nodeUuid = node.getUuid().getValue();
 249             for (OwnedNodeEdgePoint nep : node.nonnullOwnedNodeEdgePoint().values()) {
 250                 uuidNameMap.put(
 251                     String.join("--", nodeUuid, nep.getUuid().getValue()),
 252                     String.join("--", nodeName,
 253                         nep.getName().get(new NameKey(nep.getName().keySet().stream().findFirst().orElseThrow()))
 254                             .getValue()));
 255             }
 256         }
 257         return uuidNameMap;
 258     }
 259
 260     private Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> createNepForRdmNode(int nbNep) {
 261         Map<OwnedNodeEdgePointKey, OwnedNodeEdgePoint> onepMap = new HashMap<>();
 262         for (int i = 1; i <= nbNep; i++) {
 263             Name nepName = new NameBuilder()
 264                 .setValueName("NodeEdgePoint name")
 265                 .setValue(new StringBuilder("NodeEdgePoint_").append(i).toString())
 266                 .build();
 267             OwnedNodeEdgePoint onep = new OwnedNodeEdgePointBuilder()
 268                 .setUuid(new Uuid(UUID.nameUUIDFromBytes(
 269                         (String.join("+", "roadm node", "nep", String.valueOf(i))).getBytes(Charset.forName("UTF-8")))
 270                     .toString()))
 271                 .setLayerProtocolName(LayerProtocolName.PHOTONICMEDIA)
 272                 .setName(Map.of(nepName.key(), nepName))
 273                 .setSupportedCepLayerProtocolQualifierInstances(
 274                     new ArrayList<>(List.of(
 275                         new SupportedCepLayerProtocolQualifierInstancesBuilder()
 276                             .setLayerProtocolQualifier(PHOTONICLAYERQUALIFIEROTS.VALUE)
 277                             .setNumberOfCepInstances(Uint64.valueOf(1))
 278                             .build())))
 279                 .setDirection(Direction.BIDIRECTIONAL).setLinkPortRole(PortRole.SYMMETRIC)
 280                 .setAdministrativeState(AdministrativeState.UNLOCKED).setOperationalState(OperationalState.ENABLED)
 281                 .setLifecycleState(LifecycleState.INSTALLED)
 282                 .build();
 283             onepMap.put(onep.key(), onep);
 284         }
 285         return onepMap;
 286     }
 287
 288     private void createTapiOtsLinks(Map<String, String> photonicNepUuisMap, Map<String, String> rdmInfraNepUuisMap) {
 289         Iterator<Entry<String, String>> it2 = rdmInfraNepUuisMap.entrySet().iterator();
 290         for (Map.Entry<String, String> photonicEntry : photonicNepUuisMap.entrySet()) {
 291             Map.Entry<String, String> rdmEntry = it2.next();
 292             String photonicEntryKey = photonicEntry.getKey();
 293             NodeEdgePoint sourceNep = new NodeEdgePointBuilder()
 294                 .setTopologyUuid(this.tapiTopoUuid)
 295                 .setNodeUuid(new Uuid(photonicEntryKey.split("--")[0]))
 296                 .setNodeEdgePointUuid(new Uuid(photonicEntryKey.split("--")[1]))
 297                 .build();
 298             String rdmEntryKey = rdmEntry.getKey();
 299             NodeEdgePoint destNep = new NodeEdgePointBuilder()
 300                 .setTopologyUuid(this.tapiTopoUuid)
 301                 .setNodeUuid(new Uuid(rdmEntryKey.split("--")[0]))
 302                 .setNodeEdgePointUuid(new Uuid(rdmEntryKey.split("--")[1]))
 303                 .build();
 304             String linkNameValue = String.join(" and ", photonicEntry.getValue(), rdmEntry.getValue());
 305             Name linkName = new NameBuilder()
 306                 .setValueName("OTS link name")
 307                 .setValue(linkNameValue)
 308                 .build();
 309             Link otsLink = new LinkBuilder()
 310                 .setUuid(new Uuid(UUID.nameUUIDFromBytes(linkNameValue.getBytes(Charset.forName("UTF-8")))
 311                     .toString()))
 312                 .setName(Map.of(linkName.key(), linkName))
 313                 .setLayerProtocolName(Set.of(LayerProtocolName.PHOTONICMEDIA))
 314                 .setNodeEdgePoint(
 315                     new HashMap<NodeEdgePointKey, NodeEdgePoint>(Map.of(
 316                         sourceNep.key(), sourceNep, destNep.key(), destNep)))
 317                 .setDirection(ForwardingDirection.BIDIRECTIONAL)
 318                 .build();
 319             this.tapiLinks.put(otsLink.key(), otsLink);
 320         }
 321     }
 322
 323     public void setTapiNodes(Map<NodeKey,
 324             org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node> nodeMap) {
 325         this.tapiNodes.putAll(nodeMap);
 326     }
 327
 328     public Map<NodeKey, org.opendaylight.yang.gen.v1.urn.onf.otcc.yang.tapi.topology.rev221121.topology.Node>
 329             getTapiNodes() {
 330         return tapiNodes;
 331     }
 332
 333     public Map<LinkKey, Link> getTapiLinks() {
 334         return tapiLinks;
 335     }
 336
 337     public Map<ServiceInterfacePointKey, ServiceInterfacePoint> getTapiSips() {
 338         return tapiSips;
 339     }
 340
 341     public void setTapiSips(Map<ServiceInterfacePointKey, ServiceInterfacePoint> tapiSip) {
 342         this.tapiSips.putAll(tapiSip);
 343     }
 344 }