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