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