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