nemo-impl/src/main/java/org/opendaylight/nemo/intent/computation/VNMappingUnit.java

   1 /*\r
   2  * Copyright (c) 2015 Huawei, Inc. and others. All rights reserved.\r
   3  *\r
   4  * This program and the accompanying materials are made available under the\r
   5  * terms of the Eclipse Public License v1.0 which accompanies this distribution,\r
   6  * and is available at http://www.eclipse.org/legal/epl-v10.html\r
   7  */\r
   8 \r
   9 package org.opendaylight.nemo.intent.computation;\r
  10 \r
  11 import com.google.common.base.Optional;\r
  12 import org.opendaylight.controller.md.sal.binding.api.DataBroker;\r
  13 import org.opendaylight.controller.md.sal.binding.api.ReadOnlyTransaction;\r
  14 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;\r
  15 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.PhysicalNetwork;\r
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.PhysicalNodeAttributeDefinitions;\r
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.PhysicalPortAttributeDefinitions;\r
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.attribute.definition.AttributeMatchPatterns;\r
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.attribute.instance.attribute.value.RangeValue;\r
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.PhysicalNodes;\r
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.nodes.PhysicalNode;\r
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.paths.PhysicalPath;\r
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.network.physical.paths.PhysicalPathBuilder;\r
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.attribute.definitions.PhysicalNodeAttributeDefinition;\r
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.attribute.definitions.PhysicalNodeAttributeDefinitionKey;\r
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.PhysicalPort;\r
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.port.attribute.definitions.PhysicalPortAttributeDefinition;\r
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.port.attribute.definitions.PhysicalPortAttributeDefinitionKey;\r
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.port.instance.Attribute;\r
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.VirtualNetwork;\r
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.links.VirtualLink;\r
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.links.VirtualLinkBuilder;\r
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.networks.virtual.network.virtual.nodes.VirtualNode;\r
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.VirtualPort;\r
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.port.instance.PhysicalResourceRequirement;\r
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.PhysicalResourceInstance;\r
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.VirtualResourceInstance;\r
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.vn.pn.mapping.results.UserVnPnMapping;\r
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.vn.pn.mapping.results.user.vn.pn.mapping.VnPnMappingResult;\r
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.intent.mapping.result.rev151010.vn.pn.mapping.results.user.vn.pn.mapping.VnPnMappingResultBuilder;\r
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.common.rev151010.UserId;\r
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.nemo.engine.common.rev151010.*;\r
  43 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;\r
  44 import org.slf4j.Logger;\r
  45 import org.slf4j.LoggerFactory;\r
  46 \r
  47 import java.util.ArrayList;\r
  48 import java.util.LinkedList;\r
  49 import java.util.List;\r
  50 import java.util.UUID;\r
  51 import java.util.concurrent.ExecutionException;\r
  52 \r
  53 /**\r
  54  * The virtual network mapping unit implements the following functions:\r
  55  * (1) Automatically perform the virtual network mapping when the user's\r
  56  *     virtual network changed, which is subscribed from the data store.\r
  57  * (2) Automatically perform the remapping for the virtual networks that\r
  58  *     are influenced by the changes of the underlying physical network\r
  59  *     which are also subscribed from the data store.\r
  60  *\r
  61  * @author Zhigang Ji\r
  62  */\r
  63 public class VNMappingUnit implements AutoCloseable {\r
  64     private static final Logger LOG = LoggerFactory.getLogger(VNMappingUnit.class);\r
  65 \r
  66     private final DataBroker dataBroker;\r
  67 \r
  68     /**\r
  69      * The physical network computation unit.\r
  70      */\r
  71     private PNComputationUnit pnComputationUnit;\r
  72 \r
  73     /**\r
  74      * The physical network resource tracker.\r
  75      */\r
  76     private PNResourcesTracker pnResourcesTracker;\r
  77 \r
  78     public VNMappingUnit(DataBroker dataBroker,\r
  79                          PNComputationUnit pnComputationUnit,\r
  80                          PNResourcesTracker pnResourcesTracker) {\r
  81         super();\r
  82 \r
  83         this.dataBroker = dataBroker;\r
  84         this.pnComputationUnit = pnComputationUnit;\r
  85         this.pnResourcesTracker = pnResourcesTracker;\r
  86 \r
  87         LOG.debug("Initialized the virtual network mapping unit.");\r
  88 \r
  89         return;\r
  90     }\r
  91 \r
  92     /**\r
  93      * TODO\r
  94      *\r
  95      * @param virtualNetwork TODO\r
  96      * @param userVnPnMapping TODO\r
  97      * @param physicalPaths TODO\r
  98      */\r
  99     public void virtualNetworkMapping(VirtualNetwork virtualNetwork, UserVnPnMapping userVnPnMapping,\r
 100                                       List<PhysicalPath> physicalPaths)\r
 101             throws VNMappingException {\r
 102         ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();\r
 103 \r
 104         InstanceIdentifier<PhysicalNodes> physicalNodesIid = InstanceIdentifier\r
 105                 .builder(PhysicalNetwork.class)\r
 106                 .child(PhysicalNodes.class)\r
 107                 .build();\r
 108         Optional<PhysicalNodes> result;\r
 109 \r
 110         try {\r
 111             result = readOnlyTransaction.read(LogicalDatastoreType.OPERATIONAL, physicalNodesIid).get();\r
 112         } catch ( InterruptedException exception ) {\r
 113             throw new VNMappingException("Can not read the physical nodes.");\r
 114         } catch ( ExecutionException exception ) {\r
 115             throw new VNMappingException("Can not read the physical nodes.");\r
 116         }\r
 117 \r
 118         PhysicalNodes physicalNodes = result.get();\r
 119         List<PhysicalNode> physicalNodeList = physicalNodes.getPhysicalNode();\r
 120 \r
 121         UserId userId = virtualNetwork.getUserId();\r
 122         List<VnPnMappingResult> vnPnMappingResults = userVnPnMapping.getVnPnMappingResult();\r
 123         List<VirtualNode> virtualNodes = virtualNetwork.getVirtualNodes().getVirtualNode();\r
 124         List<VirtualPort> virtualPorts;\r
 125         PhysicalNode physicalNode;\r
 126         PhysicalPort physicalPort;\r
 127         VnPnMappingResult vnPnMappingResult;\r
 128 \r
 129         for ( VirtualNode virtualNode : virtualNodes ) {\r
 130             physicalNode = virtualNodeMapping(virtualNetwork.getNetworkId(), virtualNode, physicalNodeList);\r
 131 \r
 132             if ( null == physicalNode ) {\r
 133                 // If mapping failed, reset the user physical resources.\r
 134                 pnResourcesTracker.resetResource(userId);\r
 135 \r
 136                 throw new VNMappingException("Failed mapping for the virtual node " +\r
 137                         virtualNode.getNodeId().getValue() + " in the virtual network " +\r
 138                         virtualNetwork.getNetworkId().getValue());\r
 139             }\r
 140 \r
 141             // Keep physical resource.\r
 142             pnResourcesTracker.addPhysicalNode(userId, physicalNode);\r
 143 \r
 144             virtualPorts = virtualNode.getVirtualPort();\r
 145 \r
 146             for ( VirtualPort virtualPort : virtualPorts ) {\r
 147                 if ( VirtualPort.PortType.External == virtualPort.getPortType() ) {\r
 148                     physicalPort = virtualPortMapping(virtualNetwork.getNetworkId(),\r
 149                             virtualNode.getNodeId(), virtualPort, physicalNode);\r
 150 \r
 151                     if ( null == physicalPort ) {\r
 152                         // If mapping failed, reset the user physical resources.\r
 153                         pnResourcesTracker.resetResource(userId);\r
 154 \r
 155                         throw new VNMappingException("Failed mapping for the virtual port " +\r
 156                                 virtualPort.getPortId().getValue() + " of the virtual node " +\r
 157                                 virtualNode.getNodeId().getValue() + " in the virtual network " +\r
 158                                 virtualNetwork.getNetworkId().getValue());\r
 159                     }\r
 160 \r
 161                     // Keep physical resource.\r
 162                     pnResourcesTracker.addPhysicalPort(userId, physicalPort);\r
 163 \r
 164                     vnPnMappingResult = new VnPnMappingResultBuilder()\r
 165                             .setVirtualResourceId(new VirtualResourceId(UUID.randomUUID().toString()))\r
 166                             .setVirtualResourceType(VirtualResourceInstance.VirtualResourceType.Vport)\r
 167                             .setVirtualResourceEntityId(new VirtualResourceEntityId(virtualPort.getPortId().getValue()))\r
 168                             .setParentVirtualResourceEntityId(new VirtualResourceEntityId(virtualNode.getNodeId().getValue()))\r
 169                             .setPhysicalResourceId(new PhysicalResourceId(UUID.randomUUID().toString()))\r
 170                             .setPhysicalResourceType(PhysicalResourceInstance.PhysicalResourceType.Port)\r
 171                             .setPhysicalResourceEntityId(new PhysicalResourceEntityId(physicalPort.getPortId().getValue()))\r
 172                             .setParentPhysicalResourceEntityId(new PhysicalResourceEntityId(physicalNode.getNodeId().getValue()))\r
 173                             .build();\r
 174 \r
 175                     vnPnMappingResults.add(vnPnMappingResult);\r
 176                 }\r
 177             }\r
 178 \r
 179             vnPnMappingResult = new VnPnMappingResultBuilder()\r
 180                     .setVirtualResourceId(new VirtualResourceId(UUID.randomUUID().toString()))\r
 181                     .setVirtualResourceType(VirtualResourceInstance.VirtualResourceType.Vnode)\r
 182                     .setVirtualResourceEntityId(new VirtualResourceEntityId(virtualNode.getNodeId().getValue()))\r
 183                     .setPhysicalResourceId(new PhysicalResourceId(UUID.randomUUID().toString()))\r
 184                     .setPhysicalResourceType(PhysicalResourceInstance.PhysicalResourceType.Node)\r
 185                     .setPhysicalResourceEntityId(new PhysicalResourceEntityId(physicalNode.getNodeId().getValue()))\r
 186                     .build();\r
 187 \r
 188             vnPnMappingResults.add(vnPnMappingResult);\r
 189         }\r
 190 \r
 191         List<VirtualLink> virtualLinks = virtualNetwork.getVirtualLinks().getVirtualLink();\r
 192         List<VirtualLink> newVirtualLinks = new ArrayList<VirtualLink>(virtualLinks.size());\r
 193         PhysicalPath physicalPath;\r
 194         VirtualLink newVirtualLink;\r
 195 \r
 196         for ( VirtualLink virtualLink : virtualLinks ) {\r
 197             physicalPath = virtualLinkMapping(virtualNetwork.getNetworkId(), virtualLink, userVnPnMapping);\r
 198 \r
 199             if ( null == physicalPath ) {\r
 200                 // If mapping failed, reset the user physical resources.\r
 201                 pnResourcesTracker.resetResource(userId);\r
 202 \r
 203                 throw new VNMappingException("Failed mapping for the virtual link " +\r
 204                         virtualLink.getLinkId().getValue() + " in the virtual network " +\r
 205                         virtualNetwork.getNetworkId().getValue());\r
 206             }\r
 207 \r
 208             // Keep physical resource.\r
 209             pnResourcesTracker.addPhysicalPath(userId, physicalPath);\r
 210 \r
 211             physicalPaths.add(physicalPath);\r
 212 \r
 213             newVirtualLink = new VirtualLinkBuilder(virtualLink)\r
 214                     .setMetric(physicalPath.getMetric())\r
 215                     .setDelay(physicalPath.getDelay())\r
 216                     .build();\r
 217 \r
 218             newVirtualLinks.add(newVirtualLink);\r
 219 \r
 220             vnPnMappingResult = new VnPnMappingResultBuilder()\r
 221                     .setVirtualResourceId(new VirtualResourceId(UUID.randomUUID().toString()))\r
 222                     .setVirtualResourceType(VirtualResourceInstance.VirtualResourceType.Vlink)\r
 223                     .setVirtualResourceEntityId(new VirtualResourceEntityId(virtualLink.getLinkId().getValue()))\r
 224                     .setPhysicalResourceId(new PhysicalResourceId(UUID.randomUUID().toString()))\r
 225                     .setPhysicalResourceType(PhysicalResourceInstance.PhysicalResourceType.Path)\r
 226                     .setPhysicalResourceEntityId(new PhysicalResourceEntityId(physicalPath.getPathId().getValue()))\r
 227                     .build();\r
 228 \r
 229             vnPnMappingResults.add(vnPnMappingResult);\r
 230         }\r
 231 \r
 232         virtualLinks.clear();\r
 233         virtualLinks.addAll(newVirtualLinks);\r
 234 \r
 235         return;\r
 236     }\r
 237 \r
 238     /**\r
 239      * TODO\r
 240      *\r
 241      * @param virtualNetwork TODO\r
 242      * @param unmappedVirtualLinks TODO\r
 243      * @param userVnPnMapping TODO\r
 244      * @param physicalPaths TODO\r
 245      * @throws VNMappingException\r
 246      */\r
 247     public void virtualNetworkMapping(VirtualNetwork virtualNetwork, List<VirtualLink> unmappedVirtualLinks,\r
 248                                       UserVnPnMapping userVnPnMapping, List<PhysicalPath> physicalPaths)\r
 249             throws VNMappingException {\r
 250         List<VirtualLink> virtualLinks = virtualNetwork.getVirtualLinks().getVirtualLink();\r
 251         List<VnPnMappingResult> vnPnMappingResults = userVnPnMapping.getVnPnMappingResult();\r
 252         PhysicalPath physicalPath;\r
 253         VirtualLink newVirtualLink;\r
 254         VnPnMappingResult vnPnMappingResult;\r
 255         int i = virtualLinks.size() - unmappedVirtualLinks.size();\r
 256 \r
 257         for ( VirtualLink virtualLink : unmappedVirtualLinks ) {\r
 258             physicalPath = virtualLinkMapping(virtualNetwork.getNetworkId(), virtualLink, userVnPnMapping);\r
 259 \r
 260             if ( null == physicalPath ) {\r
 261                 throw new VNMappingException("Failed mapping for the virtual link " +\r
 262                         virtualLink.getLinkId().getValue() + " in the virtual network " +\r
 263                         virtualNetwork.getNetworkId().getValue());\r
 264             }\r
 265 \r
 266             physicalPaths.add(physicalPath);\r
 267 \r
 268             newVirtualLink = new VirtualLinkBuilder(virtualLink)\r
 269                     .setMetric(physicalPath.getMetric())\r
 270                     .setDelay(physicalPath.getDelay())\r
 271                     .build();\r
 272 \r
 273             virtualLinks.set(i++, newVirtualLink);\r
 274 \r
 275             vnPnMappingResult = new VnPnMappingResultBuilder()\r
 276                     .setVirtualResourceId(new VirtualResourceId(UUID.randomUUID().toString()))\r
 277                     .setVirtualResourceType(VirtualResourceInstance.VirtualResourceType.Vlink)\r
 278                     .setVirtualResourceEntityId(new VirtualResourceEntityId(virtualLink.getLinkId().getValue()))\r
 279                     .setPhysicalResourceId(new PhysicalResourceId(UUID.randomUUID().toString()))\r
 280                     .setPhysicalResourceType(PhysicalResourceInstance.PhysicalResourceType.Path)\r
 281                     .setPhysicalResourceEntityId(new PhysicalResourceEntityId(physicalPath.getPathId().getValue()))\r
 282                     .build();\r
 283 \r
 284             vnPnMappingResults.add(vnPnMappingResult);\r
 285         }\r
 286 \r
 287         return;\r
 288     }\r
 289 \r
 290     @Override\r
 291     public void close() throws Exception {\r
 292         return;\r
 293     }\r
 294 \r
 295     /**\r
 296      * TODO\r
 297      *\r
 298      * @param virtualNetworkId TODO\r
 299      * @param virtualNodeId TODO\r
 300      * @param virtualPort TODO\r
 301      * @param physicalNode TODO\r
 302      * @return TODO\r
 303      */\r
 304     private PhysicalPort virtualPortMapping(VirtualNetworkId virtualNetworkId, VirtualNodeId virtualNodeId,\r
 305                                             VirtualPort virtualPort, PhysicalNode physicalNode)\r
 306             throws VNMappingException {\r
 307         if ( VirtualPort.PortType.Internal == virtualPort.getPortType() ) {\r
 308             return null;\r
 309         }\r
 310 \r
 311         List<PhysicalPort> physicalPorts = physicalNode.getPhysicalPort();\r
 312         List<PhysicalResourceRequirement> physicalResourceRequirements = virtualPort.getPhysicalResourceRequirement();\r
 313 \r
 314         for ( PhysicalPort physicalPort : physicalPorts ) {\r
 315             if ( PhysicalPort.PortType.External == physicalPort.getPortType()\r
 316                     && checkPhysicalPortSatisfied(physicalPort, physicalResourceRequirements) ) {\r
 317                 return physicalPort;\r
 318             }\r
 319         }\r
 320 \r
 321         return null;\r
 322     }\r
 323 \r
 324     /**\r
 325      * TODO\r
 326      *\r
 327      * @param virtualNetworkId TODO\r
 328      * @param virtualNode TODO\r
 329      * @param physicalNodes TODO\r
 330      * @return TODO\r
 331      */\r
 332     private PhysicalNode virtualNodeMapping(VirtualNetworkId virtualNetworkId, VirtualNode virtualNode,\r
 333                                             List<PhysicalNode> physicalNodes)\r
 334             throws VNMappingException {\r
 335         List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement>\r
 336                 physicalResourceRequirements = virtualNode.getPhysicalResourceRequirement();\r
 337         List<PhysicalNode> candidates = new LinkedList<PhysicalNode>();\r
 338 \r
 339         switch ( virtualNode.getNodeType() ) {\r
 340             case Vswitch:\r
 341                 for ( PhysicalNode physicalNode : physicalNodes ) {\r
 342                     if ( PhysicalNode.NodeType.Switch == physicalNode.getNodeType() ) {\r
 343                         if ( checkPhysicalNodeSatisfied(physicalNode, physicalResourceRequirements) ) {\r
 344                             candidates.add(physicalNode);\r
 345                         }\r
 346                     }\r
 347                 }\r
 348                 break;\r
 349 \r
 350             case Vrouter:\r
 351                 for ( PhysicalNode physicalNode : physicalNodes ) {\r
 352                     if ( PhysicalNode.NodeType.Router == physicalNode.getNodeType() ) {\r
 353                         if ( checkPhysicalNodeSatisfied(physicalNode, physicalResourceRequirements) ) {\r
 354                             candidates.add(physicalNode);\r
 355                         }\r
 356                     }\r
 357                 }\r
 358                 break;\r
 359 \r
 360             case Vfirewall:\r
 361                 for ( PhysicalNode physicalNode : physicalNodes ) {\r
 362                     if ( PhysicalNode.NodeType.Firewall == physicalNode.getNodeType() ) {\r
 363                         if ( checkPhysicalNodeSatisfied(physicalNode, physicalResourceRequirements) ) {\r
 364                             candidates.add(physicalNode);\r
 365                         }\r
 366                     }\r
 367                 }\r
 368                 break;\r
 369 \r
 370             case Vloadbalancer:\r
 371                 for ( PhysicalNode physicalNode : physicalNodes ) {\r
 372                     if ( PhysicalNode.NodeType.Loadbalancer == physicalNode.getNodeType() ) {\r
 373                         if ( checkPhysicalNodeSatisfied(physicalNode, physicalResourceRequirements) ) {\r
 374                             candidates.add(physicalNode);\r
 375                         }\r
 376                     }\r
 377                 }\r
 378                 break;\r
 379 \r
 380             default:\r
 381                 throw new VNMappingException("Unsupported virtual node type " +\r
 382                         virtualNode.getNodeType() + ".");\r
 383 //                break;\r
 384         }\r
 385 \r
 386         if ( candidates.isEmpty() ) {\r
 387             return null;\r
 388         }\r
 389 \r
 390         return candidates.get(0);\r
 391     }\r
 392 \r
 393     /**\r
 394      * TODO\r
 395      *\r
 396      * @param virtualNetworkId TODO\r
 397      * @param virtualLink TODO\r
 398      * @param userVnPnMapping TODO\r
 399      * @return TODO\r
 400      */\r
 401     private PhysicalPath virtualLinkMapping(VirtualNetworkId virtualNetworkId, VirtualLink virtualLink,\r
 402                                             UserVnPnMapping userVnPnMapping)\r
 403             throws VNMappingException {\r
 404         List<VnPnMappingResult> vnPnMappingResults = userVnPnMapping.getVnPnMappingResult();\r
 405         VnPnMappingResult vnPnMappingResult = VNMappingUnitUtils.getVnPnMappingResult(vnPnMappingResults,\r
 406                 new VirtualResourceEntityId(virtualLink.getSrcNodeId().getValue()));\r
 407 \r
 408         if ( null == vnPnMappingResult ) {\r
 409             throw new VNMappingException("Can not get the vn-pn mapping result for " +\r
 410                     "the virtual node " + virtualLink.getSrcNodeId().getValue());\r
 411         }\r
 412 \r
 413         PhysicalNodeId source = new PhysicalNodeId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());\r
 414 \r
 415         vnPnMappingResult = VNMappingUnitUtils.getVnPnMappingResult(vnPnMappingResults,\r
 416                 new VirtualResourceEntityId(virtualLink.getDestNodeId().getValue()));\r
 417 \r
 418         if ( null == vnPnMappingResult ) {\r
 419             throw new VNMappingException("Can not get the vn-pn mapping result for " +\r
 420                     "the virtual node " + virtualLink.getDestNodeId().getValue());\r
 421         }\r
 422 \r
 423         PhysicalNodeId target = new PhysicalNodeId(vnPnMappingResult.getPhysicalResourceEntityId().getValue());\r
 424 \r
 425         if ( source.equals(target) ) {\r
 426             PhysicalPath physicalPath = new PhysicalPathBuilder()\r
 427                     .setPathId(new PhysicalPathId(UUID.randomUUID().toString()))\r
 428                     .setPhysicalLink(new ArrayList<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.path.instance.PhysicalLink>(0))\r
 429                     .setMetric(0L)\r
 430                     .setBandwidth(virtualLink.getBandwidth())\r
 431                     .setDelay(0L)\r
 432                     .build();\r
 433 \r
 434             return physicalPath;\r
 435         }\r
 436 \r
 437         PhysicalPath physicalPath;\r
 438 \r
 439         if ( 0 == virtualLink.getBandwidth() ) {\r
 440             physicalPath = pnComputationUnit.computePath(source, target);\r
 441         } else {\r
 442             physicalPath = pnComputationUnit.computePath(source, target, virtualLink.getBandwidth());\r
 443         }\r
 444 \r
 445         return physicalPath;\r
 446     }\r
 447 \r
 448     /**\r
 449      * TODO\r
 450      *\r
 451      * @param physicalPort TODO\r
 452      * @param physicalResourceRequirements TODO\r
 453      * @return TODO\r
 454      */\r
 455     private boolean checkPhysicalPortSatisfied(PhysicalPort physicalPort,\r
 456                                                List<PhysicalResourceRequirement> physicalResourceRequirements)\r
 457             throws VNMappingException {\r
 458         List<Attribute> attributes = physicalPort.getAttribute();\r
 459         Attribute attribute;\r
 460 \r
 461         for ( PhysicalResourceRequirement physicalResourceRequirement : physicalResourceRequirements ) {\r
 462             attribute = getPhysicalPortAttribute(attributes, physicalResourceRequirement.getAttributeName());\r
 463 \r
 464             if ( null == attribute ) {\r
 465                 return false;\r
 466             }\r
 467 \r
 468             if ( !checkPhysicalPortAttributeSatisfied(attribute, physicalResourceRequirement) ) {\r
 469                 return false;\r
 470             }\r
 471         }\r
 472 \r
 473         return true;\r
 474     }\r
 475 \r
 476     /**\r
 477      * TODO\r
 478      *\r
 479      * @param physicalNode TODO\r
 480      * @param physicalResourceRequirements TODO\r
 481      * @return TODO\r
 482      */\r
 483     private boolean checkPhysicalNodeSatisfied(PhysicalNode physicalNode,\r
 484                                                List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement>\r
 485                                                        physicalResourceRequirements)\r
 486             throws VNMappingException {\r
 487         List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.Attribute>\r
 488                 attributes = physicalNode.getAttribute();\r
 489         org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.Attribute attribute;\r
 490 \r
 491         for ( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement\r
 492                 physicalResourceRequirement : physicalResourceRequirements ) {\r
 493             attribute = getPhysicalNodeAttribute(attributes, physicalResourceRequirement.getAttributeName());\r
 494 \r
 495             if ( null == attribute ) {\r
 496                 return false;\r
 497             }\r
 498 \r
 499             if ( !checkPhysicalNodeAttributeSatisfied(attribute, physicalResourceRequirement) ) {\r
 500                 return false;\r
 501             }\r
 502         }\r
 503 \r
 504         return true;\r
 505     }\r
 506 \r
 507     /**\r
 508      * TODO\r
 509      *\r
 510      * @param attributes TODO\r
 511      * @param attributeName TODO\r
 512      * @return TODO\r
 513      */\r
 514     private Attribute getPhysicalPortAttribute(List<Attribute> attributes, AttributeName attributeName) {\r
 515         for ( Attribute attribute : attributes ) {\r
 516             if ( attribute.getAttributeName().equals(attributeName) ) {\r
 517                 return attribute;\r
 518             }\r
 519         }\r
 520 \r
 521         return null;\r
 522     }\r
 523 \r
 524     /**\r
 525      * TODO\r
 526      *\r
 527      * @param attributes TODO\r
 528      * @param attributeName TODO\r
 529      * @return TODO\r
 530      */\r
 531     private org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.Attribute getPhysicalNodeAttribute(\r
 532             List<org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.Attribute> attributes,\r
 533             AttributeName attributeName) {\r
 534         for ( org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.Attribute\r
 535                 attribute : attributes ) {\r
 536             if ( attribute.getAttributeName().equals(attributeName) ) {\r
 537                 return attribute;\r
 538             }\r
 539         }\r
 540 \r
 541         return null;\r
 542     }\r
 543 \r
 544     /**\r
 545      * TODO\r
 546      *\r
 547      * @param attribute TODO\r
 548      * @param physicalResourceRequirement TODO\r
 549      * @return TODO\r
 550      */\r
 551     private boolean checkPhysicalPortAttributeSatisfied(Attribute attribute,\r
 552                                                         PhysicalResourceRequirement physicalResourceRequirement)\r
 553             throws VNMappingException {\r
 554         ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();\r
 555 \r
 556         InstanceIdentifier<PhysicalPortAttributeDefinition> physicalPortAttributeDefinitionIid = InstanceIdentifier\r
 557                 .builder(PhysicalPortAttributeDefinitions.class)\r
 558                 .child(PhysicalPortAttributeDefinition.class,\r
 559                         new PhysicalPortAttributeDefinitionKey(attribute.getAttributeName()))\r
 560                 .build();\r
 561         Optional<PhysicalPortAttributeDefinition> result;\r
 562 \r
 563         try {\r
 564             result = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION,\r
 565                     physicalPortAttributeDefinitionIid).get();\r
 566         } catch ( InterruptedException exception ) {\r
 567             throw new VNMappingException("Can not read the physical port attribute definition " +\r
 568                     "with attribute name " + attribute.getAttributeName().getValue() + ".");\r
 569         } catch ( ExecutionException exception ) {\r
 570             throw new VNMappingException("Can not read the physical port attribute definition " +\r
 571                     "with attribute name " + attribute.getAttributeName().getValue() + ".");\r
 572         }\r
 573 \r
 574         if ( !result.isPresent() ) {\r
 575             throw new VNMappingException("The physical port attribute definition with attribute name " +\r
 576                     attribute.getAttributeName().getValue() + " does not exist.");\r
 577         }\r
 578 \r
 579         PhysicalPortAttributeDefinition physicalPortAttributeDefinition = result.get();\r
 580         List<AttributeMatchPatterns.AttributeMatchPattern> attributeMatchPatterns\r
 581                 = physicalPortAttributeDefinition.getAttributeMatchPatterns().getAttributeMatchPattern();\r
 582         PhysicalResourceRequirement.AttributeMatchPattern attributeMatchPattern\r
 583                 = physicalResourceRequirement.getAttributeMatchPattern();\r
 584 \r
 585         if ( !checkAttributeMatchPatternSpecified(attributeMatchPatterns, attributeMatchPattern) ) {\r
 586             throw new VNMappingException("The attribute match pattern " + attributeMatchPattern +\r
 587                     " is not specified in the physical port attribute definition " +\r
 588                     "with attribute name " + attribute.getAttributeName().getValue() + ".");\r
 589         }\r
 590 \r
 591         switch ( physicalPortAttributeDefinition.getAttributeValueType() ) {\r
 592             case String:\r
 593                 return checkAttributeStringValueSatisfied(attribute.getAttributeValue().getStringValue(),\r
 594                         physicalResourceRequirement.getAttributeValue().getStringValue(), attributeMatchPattern);\r
 595 \r
 596             case Int:\r
 597                 return checkAttributeIntegerValueSatisfied(attribute.getAttributeValue().getIntValue(),\r
 598                         physicalResourceRequirement.getAttributeValue().getIntValue(), attributeMatchPattern);\r
 599 \r
 600             case Range:\r
 601                 return checkAttributeRangeValueSatisfied(attribute.getAttributeValue().getIntValue(),\r
 602                         physicalResourceRequirement.getAttributeValue().getRangeValue(), attributeMatchPattern);\r
 603 \r
 604             default:\r
 605                 throw new VNMappingException("Unsupported physical port attribute value type " +\r
 606                         physicalPortAttributeDefinition.getAttributeValueType() + ".");\r
 607 //                break;\r
 608         }\r
 609 \r
 610 //        return false;\r
 611     }\r
 612 \r
 613     /**\r
 614      * TODO\r
 615      *\r
 616      * @param attribute TODO\r
 617      * @param physicalResourceRequirement TODO\r
 618      * @return TODO\r
 619      */\r
 620     private boolean checkPhysicalNodeAttributeSatisfied(\r
 621             org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.physical.network.rev151010.physical.node.instance.Attribute attribute,\r
 622             org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement physicalResourceRequirement)\r
 623             throws VNMappingException {\r
 624         ReadOnlyTransaction readOnlyTransaction = dataBroker.newReadOnlyTransaction();\r
 625 \r
 626         InstanceIdentifier<PhysicalNodeAttributeDefinition> physicalNodeAttributeDefinitionIid = InstanceIdentifier\r
 627                 .builder(PhysicalNodeAttributeDefinitions.class)\r
 628                 .child(PhysicalNodeAttributeDefinition.class,\r
 629                         new PhysicalNodeAttributeDefinitionKey(attribute.getAttributeName()))\r
 630                 .build();\r
 631         Optional<PhysicalNodeAttributeDefinition> result;\r
 632 \r
 633         try {\r
 634             result = readOnlyTransaction.read(LogicalDatastoreType.CONFIGURATION,\r
 635                     physicalNodeAttributeDefinitionIid).get();\r
 636         } catch ( InterruptedException exception ) {\r
 637             throw new VNMappingException("Can not read the physical node attribute definition " +\r
 638                     "with attribute name " + attribute.getAttributeName().getValue() + ".");\r
 639         } catch ( ExecutionException exception ) {\r
 640             throw new VNMappingException("Can not read the physical node attribute definition " +\r
 641                     "with attribute name " + attribute.getAttributeName().getValue() + ".");\r
 642         }\r
 643 \r
 644         if ( !result.isPresent() ) {\r
 645             throw new VNMappingException("The physical node attribute definition with attribute name " +\r
 646                     attribute.getAttributeName().getValue() + " does not exist.");\r
 647         }\r
 648 \r
 649         PhysicalNodeAttributeDefinition physicalNodeAttributeDefinition = result.get();\r
 650         List<AttributeMatchPatterns.AttributeMatchPattern> attributeMatchPatterns\r
 651                 = physicalNodeAttributeDefinition.getAttributeMatchPatterns().getAttributeMatchPattern();\r
 652         org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement.AttributeMatchPattern\r
 653                 attributeMatchPattern = physicalResourceRequirement.getAttributeMatchPattern();\r
 654 \r
 655         if ( !checkAttributeMatchPatternSpecified(attributeMatchPatterns, attributeMatchPattern) ) {\r
 656             throw new VNMappingException("The attribute match pattern " + attributeMatchPattern +\r
 657                     " is not specified in the physical node attribute definition " +\r
 658                     "with attribute name " + attribute.getAttributeName().getValue() + ".");\r
 659         }\r
 660 \r
 661         switch ( physicalNodeAttributeDefinition.getAttributeValueType() ) {\r
 662             case String:\r
 663                 return checkAttributeStringValueSatisfied(attribute.getAttributeValue().getStringValue(),\r
 664                         physicalResourceRequirement.getAttributeValue().getStringValue(), attributeMatchPattern);\r
 665 \r
 666             case Int:\r
 667                 return checkAttributeIntegerValueSatisfied(attribute.getAttributeValue().getIntValue(),\r
 668                         physicalResourceRequirement.getAttributeValue().getIntValue(), attributeMatchPattern);\r
 669 \r
 670             case Range:\r
 671                 return checkAttributeRangeValueSatisfied(attribute.getAttributeValue().getIntValue(),\r
 672                         physicalResourceRequirement.getAttributeValue().getRangeValue(), attributeMatchPattern);\r
 673 \r
 674             default:\r
 675                 throw new VNMappingException("Unsupported physical node attribute value type " +\r
 676                         physicalNodeAttributeDefinition.getAttributeValueType() + ".");\r
 677 //                break;\r
 678         }\r
 679 \r
 680 //        return false;\r
 681     }\r
 682 \r
 683     /**\r
 684      * TODO\r
 685      *\r
 686      * @param attributeMatchPatterns TODO\r
 687      * @param attributeMatchPattern TODO\r
 688      * @return TODO\r
 689      */\r
 690     private boolean checkAttributeMatchPatternSpecified(List<AttributeMatchPatterns.AttributeMatchPattern> attributeMatchPatterns,\r
 691                                                         PhysicalResourceRequirement.AttributeMatchPattern attributeMatchPattern) {\r
 692         for ( AttributeMatchPatterns.AttributeMatchPattern attributeMatchPattern1 : attributeMatchPatterns ) {\r
 693             if ( attributeMatchPattern1.name().equals(attributeMatchPattern.name()) ) {\r
 694                 return true;\r
 695             }\r
 696         }\r
 697 \r
 698         return false;\r
 699     }\r
 700 \r
 701     /**\r
 702      * TODO\r
 703      *\r
 704      * @param attributeMatchPatterns TODO\r
 705      * @param attributeMatchPattern TODO\r
 706      * @return TODO\r
 707      */\r
 708     private boolean checkAttributeMatchPatternSpecified(List<AttributeMatchPatterns.AttributeMatchPattern> attributeMatchPatterns,\r
 709                                                         org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement.AttributeMatchPattern\r
 710                                                                 attributeMatchPattern) {\r
 711         for ( AttributeMatchPatterns.AttributeMatchPattern attributeMatchPattern1 : attributeMatchPatterns ) {\r
 712             if ( attributeMatchPattern1.name().equals(attributeMatchPattern.name()) ) {\r
 713                 return true;\r
 714             }\r
 715         }\r
 716 \r
 717         return false;\r
 718     }\r
 719 \r
 720     /**\r
 721      * TODO\r
 722      *\r
 723      * @param attributeValue TODO\r
 724      * @param requiredAttributeValue TODO\r
 725      * @param attributeMatchPattern TODO\r
 726      * @return TODO\r
 727      */\r
 728     private boolean checkAttributeStringValueSatisfied(String attributeValue, String requiredAttributeValue,\r
 729                                                        PhysicalResourceRequirement.AttributeMatchPattern attributeMatchPattern)\r
 730             throws VNMappingException {\r
 731         int result = attributeValue.compareTo(requiredAttributeValue);\r
 732 \r
 733         switch ( attributeMatchPattern ) {\r
 734             case LessThan:\r
 735                 return 0 > result;\r
 736 \r
 737             case NotLessThan:\r
 738                 return 0 <= result;\r
 739 \r
 740             case Equal:\r
 741                 return 0 == result;\r
 742 \r
 743             case NotEqual:\r
 744                 return 0 != result;\r
 745 \r
 746             case GreaterThan:\r
 747                 return 0 < result;\r
 748 \r
 749             case NotGreaterThan:\r
 750                 return 0 >= result;\r
 751 \r
 752             default:\r
 753                 throw new VNMappingException("Unsupported attribute match pattern " +\r
 754                         attributeMatchPattern + " for the attribute string value.");\r
 755 //                break;\r
 756         }\r
 757 \r
 758 //        return false;\r
 759     }\r
 760 \r
 761     /**\r
 762      * TODO\r
 763      *\r
 764      * @param attributeValue TODO\r
 765      * @param requiredAttributeValue TODO\r
 766      * @param attributeMatchPattern TODO\r
 767      * @return TODO\r
 768      */\r
 769     private boolean checkAttributeStringValueSatisfied(String attributeValue, String requiredAttributeValue,\r
 770                                                        org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement.AttributeMatchPattern\r
 771                                                                attributeMatchPattern)\r
 772             throws VNMappingException {\r
 773         int result = attributeValue.compareTo(requiredAttributeValue);\r
 774 \r
 775         switch ( attributeMatchPattern ) {\r
 776             case LessThan:\r
 777                 return 0 > result;\r
 778 \r
 779             case NotLessThan:\r
 780                 return 0 <= result;\r
 781 \r
 782             case Equal:\r
 783                 return 0 == result;\r
 784 \r
 785             case NotEqual:\r
 786                 return 0 != result;\r
 787 \r
 788             case GreaterThan:\r
 789                 return 0 < result;\r
 790 \r
 791             case NotGreaterThan:\r
 792                 return 0 >= result;\r
 793 \r
 794             default:\r
 795                 throw new VNMappingException("Unsupported attribute match pattern " +\r
 796                         attributeMatchPattern + " for the attribute string value.");\r
 797 //                break;\r
 798         }\r
 799 \r
 800 //        return false;\r
 801     }\r
 802 \r
 803     /**\r
 804      * TODO\r
 805      *\r
 806      * @param attributeValue TODO\r
 807      * @param requiredAttributeValue TODO\r
 808      * @param attributeMatchPattern TODO\r
 809      * @return TODO\r
 810      */\r
 811     private boolean checkAttributeIntegerValueSatisfied(Long attributeValue, Long requiredAttributeValue,\r
 812                                                         PhysicalResourceRequirement.AttributeMatchPattern attributeMatchPattern)\r
 813             throws VNMappingException {\r
 814         int result = attributeValue.compareTo(requiredAttributeValue);\r
 815 \r
 816         switch ( attributeMatchPattern ) {\r
 817             case LessThan:\r
 818                 return 0 > result;\r
 819 \r
 820             case NotLessThan:\r
 821                 return 0 <= result;\r
 822 \r
 823             case Equal:\r
 824                 return 0 == result;\r
 825 \r
 826             case NotEqual:\r
 827                 return 0 != result;\r
 828 \r
 829             case GreaterThan:\r
 830                 return 0 < result;\r
 831 \r
 832             case NotGreaterThan:\r
 833                 return 0 >= result;\r
 834 \r
 835             default:\r
 836                 throw new VNMappingException("Unsupported attribute match pattern " +\r
 837                         attributeMatchPattern + " for the attribute integer value.");\r
 838 //                break;\r
 839         }\r
 840 \r
 841 //        return false;\r
 842     }\r
 843 \r
 844     /**\r
 845      * TODO\r
 846      *\r
 847      * @param attributeValue TODO\r
 848      * @param requiredAttributeValue TODO\r
 849      * @param attributeMatchPattern TODO\r
 850      * @return TODO\r
 851      */\r
 852     private boolean checkAttributeIntegerValueSatisfied(Long attributeValue, Long requiredAttributeValue,\r
 853                                                         org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement.AttributeMatchPattern\r
 854                                                                 attributeMatchPattern)\r
 855             throws VNMappingException {\r
 856         int result = attributeValue.compareTo(requiredAttributeValue);\r
 857 \r
 858         switch ( attributeMatchPattern ) {\r
 859             case LessThan:\r
 860                 return 0 > result;\r
 861 \r
 862             case NotLessThan:\r
 863                 return 0 <= result;\r
 864 \r
 865             case Equal:\r
 866                 return 0 == result;\r
 867 \r
 868             case NotEqual:\r
 869                 return 0 != result;\r
 870 \r
 871             case GreaterThan:\r
 872                 return 0 < result;\r
 873 \r
 874             case NotGreaterThan:\r
 875                 return 0 >= result;\r
 876 \r
 877             default:\r
 878                 throw new VNMappingException("Unsupported attribute match pattern " +\r
 879                         attributeMatchPattern + " for the attribute integer value.");\r
 880 //                break;\r
 881         }\r
 882 \r
 883 //        return false;\r
 884     }\r
 885 \r
 886     /**\r
 887      * TODO\r
 888      *\r
 889      * @param attributeValue TODO\r
 890      * @param requiredAttributeValue TODO\r
 891      * @param attributeMatchPattern TODO\r
 892      * @return TODO\r
 893      */\r
 894     private boolean checkAttributeRangeValueSatisfied(Long attributeValue, RangeValue requiredAttributeValue,\r
 895                                                       PhysicalResourceRequirement.AttributeMatchPattern attributeMatchPattern)\r
 896             throws VNMappingException {\r
 897         switch ( attributeMatchPattern ) {\r
 898             case Between:\r
 899                 return attributeValue > requiredAttributeValue.getMin()\r
 900                         && attributeValue < requiredAttributeValue.getMax();\r
 901 \r
 902             default:\r
 903                 throw new VNMappingException("Unsupported attribute match pattern " +\r
 904                         attributeMatchPattern + " for the attribute range value.");\r
 905 //                break;\r
 906         }\r
 907 \r
 908 //        return false;\r
 909     }\r
 910 \r
 911     /**\r
 912      * TODO\r
 913      *\r
 914      * @param attributeValue TODO\r
 915      * @param requiredAttributeValue TODO\r
 916      * @param attributeMatchPattern TODO\r
 917      * @return TODO\r
 918      */\r
 919     private boolean checkAttributeRangeValueSatisfied(Long attributeValue, RangeValue requiredAttributeValue,\r
 920                                                       org.opendaylight.yang.gen.v1.urn.opendaylight.params.xml.ns.yang.generic.virtual.network.rev151010.virtual.node.instance.PhysicalResourceRequirement.AttributeMatchPattern\r
 921                                                               attributeMatchPattern)\r
 922             throws VNMappingException {\r
 923         switch ( attributeMatchPattern ) {\r
 924             case Between:\r
 925                 return attributeValue > requiredAttributeValue.getMin()\r
 926                         && attributeValue < requiredAttributeValue.getMax();\r
 927 \r
 928             default:\r
 929                 throw new VNMappingException("Unsupported attribute match pattern " +\r
 930                         attributeMatchPattern + " for the attribute range value.");\r
 931 //                break;\r
 932         }\r
 933 \r
 934 //        return false;\r
 935     }\r
 936 \r
 937 //    /**\r
 938 //     * A listener to change events related to virtual ports being\r
 939 //     * added, removed or updated.\r
 940 //     *\r
 941 //     * @author Zhigang Ji\r
 942 //     */\r
 943 //    private class VirtualPortChangeListener implements DataChangeListener {\r
 944 //        /**\r
 945 //         * The virtual network that the virtual port belongs to.\r
 946 //         */\r
 947 //        private VirtualNetworkId virtualNetworkId;\r
 948 //\r
 949 //        /**\r
 950 //         * The virtual node that the virtual port belongs to.\r
 951 //         */\r
 952 //        private VirtualNodeId virtualNodeId;\r
 953 //\r
 954 //        public VirtualPortChangeListener(VirtualNetworkId virtualNetworkId, VirtualNodeId virtualNodeId) {\r
 955 //            super();\r
 956 //\r
 957 //            this.virtualNetworkId = virtualNetworkId;\r
 958 //            this.virtualNodeId = virtualNodeId;\r
 959 //\r
 960 //            return;\r
 961 //        }\r
 962 //\r
 963 //        @Override\r
 964 //        public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {\r
 965 //            if ( null == change ) {\r
 966 //                return;\r
 967 //            }\r
 968 //\r
 969 //            Map<InstanceIdentifier<?>, DataObject> createdData = change.getCreatedData();\r
 970 //\r
 971 //            if ( null != createdData && !createdData.isEmpty() ) {\r
 972 //                for ( DataObject dataObject : createdData.values() ) {\r
 973 //                    if ( dataObject instanceof VirtualPort ) {\r
 974 //                        // TODO: 1、执行端口映射。\r
 975 //                    }\r
 976 //                }\r
 977 //            }\r
 978 //        }\r
 979 //    }\r
 980 //\r
 981 //    /**\r
 982 //     * A listener to change events related to virtual nodes being\r
 983 //     * added, removed or updated.\r
 984 //     *\r
 985 //     * @author Zhigang Ji\r
 986 //     */\r
 987 //    private class VirtualNodeChangeListener implements DataChangeListener {\r
 988 //        /**\r
 989 //         * The virtual network that the virtual node belongs to.\r
 990 //         */\r
 991 //        private VirtualNetworkId virtualNetworkId;\r
 992 //\r
 993 //        public VirtualNodeChangeListener(VirtualNetworkId virtualNetworkId) {\r
 994 //            super();\r
 995 //\r
 996 //            this.virtualNetworkId = virtualNetworkId;\r
 997 //\r
 998 //            return;\r
 999 //        }\r
1000 //\r
1001 //        @Override\r
1002 //        public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {\r
1003 //            if ( null == change ) {\r
1004 //                return;\r
1005 //            }\r
1006 //\r
1007 //            Map<InstanceIdentifier<?>, DataObject> createdData = change.getCreatedData();\r
1008 //\r
1009 //            if ( null != createdData && !createdData.isEmpty() ) {\r
1010 //                for ( DataObject dataObject : createdData.values() ) {\r
1011 //                    if ( dataObject instanceof VirtualNode ) {\r
1012 //                        // TODO: 1、执行节点映射。\r
1013 //                        // TODO: 2、启动vports监听(external端口)，还需监听vnode中vport的增加。\r
1014 //                        // TODO: 3、读取已有vports，并执行端口映射(external端口)。\r
1015 //                    }\r
1016 //                }\r
1017 //            }\r
1018 //        }\r
1019 //    }\r
1020 //\r
1021 //    /**\r
1022 //     * A listener to change events related to virtual links being\r
1023 //     * added, removed or updated.\r
1024 //     *\r
1025 //     * @author Zhigang Ji\r
1026 //     */\r
1027 //    private class VirtualLinkChangeListener implements DataChangeListener {\r
1028 //        /**\r
1029 //         * The virtual network that the virtual link belongs to.\r
1030 //         */\r
1031 //        private VirtualNetworkId virtualNetworkId;\r
1032 //\r
1033 //        public VirtualLinkChangeListener(VirtualNetworkId virtualNetworkId) {\r
1034 //            super();\r
1035 //\r
1036 //            this.virtualNetworkId = virtualNetworkId;\r
1037 //\r
1038 //            return;\r
1039 //        }\r
1040 //\r
1041 //        @Override\r
1042 //        public void onDataChanged(AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> change) {\r
1043 //            if ( null == change ) {\r
1044 //                return;\r
1045 //            }\r
1046 //\r
1047 //            Map<InstanceIdentifier<?>, DataObject> createdData = change.getCreatedData();\r
1048 //\r
1049 //            if ( null != createdData && !createdData.isEmpty() ) {\r
1050 //                for ( DataObject dataObject : createdData.values() ) {\r
1051 //                    if ( dataObject instanceof VirtualLink ) {\r
1052 //                        // TODO: 1、执行链路映射(两端vport映射结果可不写)。\r
1053 //                    }\r
1054 //                }\r
1055 //            }\r
1056 //        }\r
1057 //    }\r
1058 }\r