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