opendaylight/md-sal/compatibility/sal-compatibility/src/main/java/org/opendaylight/controller/sal/compatibility/InventoryAndReadAdapter.xtend

   1 package org.opendaylight.controller.sal.compatibility
   2
   3 import java.util.ArrayList
   4 import java.util.Collections
   5 import java.util.List
   6 import org.opendaylight.controller.sal.binding.api.data.DataBrokerService
   7 import org.opendaylight.controller.sal.binding.api.data.DataProviderService
   8 import org.opendaylight.controller.sal.core.Edge
   9 import org.opendaylight.controller.sal.core.Node
  10 import org.opendaylight.controller.sal.core.NodeTable
  11 import org.opendaylight.controller.sal.core.UpdateType
  12 import org.opendaylight.controller.sal.flowprogrammer.Flow
  13 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService
  14 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService
  15 import org.opendaylight.controller.sal.reader.FlowOnNode
  16 import org.opendaylight.controller.sal.reader.IPluginInReadService
  17 import org.opendaylight.controller.sal.reader.IPluginOutReadService
  18 import org.opendaylight.controller.sal.reader.NodeConnectorStatistics
  19 import org.opendaylight.controller.sal.reader.NodeDescription
  20 import org.opendaylight.controller.sal.reader.NodeTableStatistics
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdate
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdate
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowsStatisticsFromAllFlowTablesInputBuilder
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableInputBuilder
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsListener
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsService
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsUpdate
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.GetFlowTablesStatisticsInputBuilder
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsListener
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsService
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.statistics.FlowTableStatistics
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryService
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.Link
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey
  54 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatistics
  55 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData
  56 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllNodeConnectorsStatisticsInputBuilder
  57 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetNodeConnectorStatisticsInputBuilder
  58 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.NodeConnectorStatisticsUpdate
  59 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsListener
  60 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService
  61 import org.opendaylight.yangtools.yang.binding.DataObject
  62 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
  63 import org.slf4j.LoggerFactory
  64
  65 import static extension org.opendaylight.controller.sal.common.util.Arguments.*
  66 import static extension org.opendaylight.controller.sal.compatibility.NodeMapping.*
  67
  68 class InventoryAndReadAdapter implements IPluginInReadService,
  69                                                                                          IPluginInInventoryService,
  70                                                                                          OpendaylightInventoryListener,
  71                                                                                          OpendaylightFlowStatisticsListener,
  72                                                                                          OpendaylightFlowTableStatisticsListener,
  73                                                                                          OpendaylightPortStatisticsListener {
  74
  75     private static val LOG = LoggerFactory.getLogger(InventoryAndReadAdapter);
  76
  77         private static val OPENFLOWV10_TABLE_ID = new Integer(0).shortValue;
  78     @Property
  79     DataBrokerService dataService;
  80
  81     @Property
  82     DataProviderService dataProviderService;
  83
  84     @Property
  85     OpendaylightFlowStatisticsService flowStatisticsService;
  86
  87     @Property
  88     OpendaylightPortStatisticsService nodeConnectorStatisticsService;
  89
  90     @Property
  91     OpendaylightFlowTableStatisticsService flowTableStatisticsService;
  92
  93     @Property
  94     IPluginOutInventoryService inventoryPublisher;
  95
  96     @Property
  97     FlowTopologyDiscoveryService topologyDiscovery;
  98
  99     @Property
 100     List<IPluginOutReadService> statisticsPublisher = new ArrayList<IPluginOutReadService>();
 101
 102     def setReadPublisher(IPluginOutReadService listener) {
 103         statisticsPublisher.add(listener);
 104     }
 105
 106     def unsetReadPublisher (IPluginOutReadService listener) {
 107         if( listener != null)
 108                 statisticsPublisher.remove(listener);
 109     }
 110
 111     protected def startChange() {
 112         return dataProviderService.beginTransaction;
 113     }
 114
 115     override getTransmitRate(org.opendaylight.controller.sal.core.NodeConnector connector) {
 116         val nodeConnector = readFlowCapableNodeConnector(connector.toNodeConnectorRef);
 117         return nodeConnector.currentSpeed
 118     }
 119
 120     override readAllFlow(Node node, boolean cached) {
 121
 122         val output = new ArrayList<FlowOnNode>();
 123                 val tableRef = InstanceIdentifier.builder(Nodes)
 124                                                                                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node))
 125                                                         .augmentation(FlowCapableNode).child(Table, new TableKey(OPENFLOWV10_TABLE_ID)).toInstance();
 126
 127                 val it = this.startChange();
 128
 129                 val table= it.readConfigurationData(tableRef) as Table;
 130
 131                 if(table != null){
 132                         LOG.info("Number of flows installed in table 0 of node {} : {}",node,table.flow.size);
 133
 134                         for(flow : table.flow){
 135
 136                                 val adsalFlow = ToSalConversionsUtils.toFlow(flow);
 137                                 val statsFromDataStore = flow.getAugmentation(FlowStatisticsData) as FlowStatisticsData;
 138
 139                                 if(statsFromDataStore != null){
 140                                         val it = new FlowOnNode(adsalFlow);
 141                                         byteCount =  statsFromDataStore.flowStatistics.byteCount.value.longValue;
 142                                         packetCount = statsFromDataStore.flowStatistics.packetCount.value.longValue;
 143                                         durationSeconds = statsFromDataStore.flowStatistics.duration.second.value.intValue;
 144                                         durationNanoseconds = statsFromDataStore.flowStatistics.duration.nanosecond.value.intValue;
 145
 146                                         output.add(it);
 147                                 }
 148                         }
 149                 }
 150
 151         //TODO (main): Shell we send request to the switch? It will make async request to the switch.
 152         // Once plugin receive response, it will let adaptor know through onFlowStatisticsUpdate()
 153         // If we assume that md-sal statistics manager will always be running, then its not required
 154         // But if not, then sending request will collect the latest data for adaptor atleast.
 155         val input = new GetAllFlowsStatisticsFromAllFlowTablesInputBuilder;
 156         input.setNode(node.toNodeRef);
 157         flowStatisticsService.getAllFlowsStatisticsFromAllFlowTables(input.build)
 158
 159         return output;
 160     }
 161
 162     override readAllNodeConnector(Node node, boolean cached) {
 163
 164         val ret = new ArrayList<NodeConnectorStatistics>();
 165                 val nodeRef = InstanceIdentifier.builder(Nodes)
 166                                                                         .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node))
 167                                                                         .toInstance();
 168
 169                 val provider = this.startChange();
 170
 171                 val dsNode= provider.readConfigurationData(nodeRef) as org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
 172
 173                 if(dsNode != null){
 174
 175                         for (dsNodeConnector : dsNode.nodeConnector){
 176                                 val nodeConnectorRef = InstanceIdentifier.builder(Nodes)
 177                                                                         .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node))
 178                                                                         .child(NodeConnector, dsNodeConnector.key)
 179                                                                         .toInstance();
 180
 181                                 val nodeConnectorFromDS = provider.readConfigurationData(nodeConnectorRef) as NodeConnector;
 182
 183                                 if(nodeConnectorFromDS != null){
 184                                         val nodeConnectorStatsFromDs = nodeConnectorFromDS.getAugmentation(FlowCapableNodeConnectorStatisticsData) as FlowCapableNodeConnectorStatistics;
 185
 186                                         ret.add(toNodeConnectorStatistics(nodeConnectorStatsFromDs.flowCapableNodeConnectorStatistics,dsNode.id,dsNodeConnector.id));
 187                                 }
 188                         }
 189                 }
 190
 191                 //TODO: Refer TODO (main)
 192         val input = new GetAllNodeConnectorsStatisticsInputBuilder();
 193         input.setNode(node.toNodeRef);
 194         nodeConnectorStatisticsService.getAllNodeConnectorsStatistics(input.build());
 195         return ret;
 196     }
 197
 198     override readAllNodeTable(Node node, boolean cached) {
 199         val ret = new ArrayList<NodeTableStatistics>();
 200
 201                 val dsFlowCapableNode= readFlowCapableNode(node.toNodeRef)
 202
 203                 if(dsFlowCapableNode != null){
 204
 205                         for (table : dsFlowCapableNode.table){
 206
 207                                 val tableStats = table.getAugmentation(FlowTableStatisticsData) as FlowTableStatisticsData;
 208
 209                                 if(tableStats != null){
 210                                         ret.add(toNodeTableStatistics(tableStats.flowTableStatistics,table.id,node));
 211                                 }
 212                         }
 213                 }
 214
 215                 //TODO: Refer TODO (main)
 216         val input = new GetFlowTablesStatisticsInputBuilder();
 217         input.setNode(node.toNodeRef);
 218         flowTableStatisticsService.getFlowTablesStatistics(input.build);
 219         return ret;
 220     }
 221
 222     override readDescription(Node node, boolean cached) {
 223         return toNodeDescription(node.toNodeRef);
 224         }
 225
 226     override readFlow(Node node, Flow targetFlow, boolean cached) {
 227                 var FlowOnNode ret= null;
 228
 229                 val tableRef = InstanceIdentifier.builder(Nodes)
 230                                                                                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(node))
 231                                                         .augmentation(FlowCapableNode).child(Table, new TableKey(OPENFLOWV10_TABLE_ID)).toInstance();
 232
 233                 val it = this.startChange();
 234
 235                 val table= it.readConfigurationData(tableRef) as Table;
 236
 237                 if(table != null){
 238                         LOG.info("Number of flows installed in table 0 of node {} : {}",node,table.flow.size);
 239
 240                         for(mdsalFlow : table.flow){
 241                                 if(FromSalConversionsUtils.flowEquals(mdsalFlow, MDFlowMapping.toMDSalflow(targetFlow))){
 242                                         val statsFromDataStore = mdsalFlow.getAugmentation(FlowStatisticsData) as FlowStatisticsData;
 243
 244                                         if(statsFromDataStore != null){
 245                                                 LOG.debug("Found matching flow in the data store flow table ");
 246                                                 val it = new FlowOnNode(targetFlow);
 247                                                 byteCount =  statsFromDataStore.flowStatistics.byteCount.value.longValue;
 248                                                 packetCount = statsFromDataStore.flowStatistics.packetCount.value.longValue;
 249                                                 durationSeconds = statsFromDataStore.flowStatistics.duration.second.value.intValue;
 250                                                 durationNanoseconds = statsFromDataStore.flowStatistics.duration.nanosecond.value.intValue;
 251
 252                                                 ret = it;
 253                                         }
 254                                 }
 255                         }
 256                 }
 257
 258         //TODO: Refer TODO (main)
 259         val input = new GetFlowStatisticsFromFlowTableInputBuilder;
 260         input.setNode(node.toNodeRef);
 261         input.fieldsFrom(MDFlowMapping.toMDSalflow(targetFlow));
 262         flowStatisticsService.getFlowStatisticsFromFlowTable(input.build)
 263
 264         return ret;
 265
 266     }
 267
 268     override readNodeConnector(org.opendaylight.controller.sal.core.NodeConnector connector, boolean cached) {
 269         var NodeConnectorStatistics  nodeConnectorStatistics = null;
 270
 271                 val nodeConnectorRef = InstanceIdentifier.builder(Nodes)
 272                                                                         .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(connector.node))
 273                                                                         .child(NodeConnector, InventoryMapping.toNodeConnectorKey(connector))
 274                                                                         .toInstance();
 275                 val provider = this.startChange();
 276
 277                 val nodeConnectorFromDS = provider.readConfigurationData(nodeConnectorRef) as NodeConnector;
 278
 279                 if(nodeConnectorFromDS != null){
 280                         val nodeConnectorStatsFromDs = nodeConnectorFromDS.getAugmentation(FlowCapableNodeConnectorStatisticsData) as FlowCapableNodeConnectorStatistics;
 281                         if(nodeConnectorStatsFromDs != null) {
 282                                 nodeConnectorStatistics = toNodeConnectorStatistics(nodeConnectorStatsFromDs.flowCapableNodeConnectorStatistics,
 283                                                                                                                                                 InventoryMapping.toNodeKey(connector.node).id,
 284                                                                                                                                                 InventoryMapping.toNodeConnectorKey(connector).id);
 285                         }
 286                 }
 287
 288                 //TODO: Refer TODO (main)
 289         val input = new GetNodeConnectorStatisticsInputBuilder();
 290         input.setNode(connector.node.toNodeRef);
 291         input.setNodeConnectorId(InventoryMapping.toNodeConnectorKey(connector).id);
 292         nodeConnectorStatisticsService.getNodeConnectorStatistics(input.build());
 293         return nodeConnectorStatistics;
 294     }
 295
 296     override readNodeTable(NodeTable nodeTable, boolean cached) {
 297         var NodeTableStatistics nodeStats = null
 298
 299         val tableRef = InstanceIdentifier.builder(Nodes)
 300                                                                                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node, InventoryMapping.toNodeKey(nodeTable.node))
 301                                                         .augmentation(FlowCapableNode).child(Table, new TableKey(nodeTable.ID as Short)).toInstance();
 302
 303                 val it = this.startChange();
 304
 305                 val table= it.readConfigurationData(tableRef) as Table;
 306
 307                 if(table != null){
 308                         val tableStats = table.getAugmentation(FlowTableStatisticsData) as FlowTableStatisticsData;
 309
 310                         if(tableStats != null){
 311                                 nodeStats =  toNodeTableStatistics(tableStats.flowTableStatistics,table.id,nodeTable.node);
 312                         }
 313                 }
 314
 315                 //TODO: Refer TODO (main)
 316         val input = new GetFlowTablesStatisticsInputBuilder();
 317         input.setNode(nodeTable.node.toNodeRef);
 318         flowTableStatisticsService.getFlowTablesStatistics(input.build);
 319
 320         return nodeStats;
 321     }
 322
 323     override onNodeConnectorRemoved(NodeConnectorRemoved update) {
 324         // NOOP
 325     }
 326
 327     override onNodeRemoved(NodeRemoved notification) {
 328         val properties = Collections.<org.opendaylight.controller.sal.core.Property>emptySet();
 329
 330         inventoryPublisher.updateNode(notification.nodeRef.toADNode, UpdateType.REMOVED, properties);
 331     }
 332
 333     override onNodeConnectorUpdated(NodeConnectorUpdated update) {
 334         var updateType = UpdateType.CHANGED;
 335         if ( this._dataService.readOperationalData(update.nodeConnectorRef.value as InstanceIdentifier<? extends DataObject>) == null ){
 336             updateType = UpdateType.ADDED;
 337         }
 338
 339         var nodeConnector = update.nodeConnectorRef.toADNodeConnector
 340
 341         inventoryPublisher.updateNodeConnector(nodeConnector , updateType , update.toADNodeConnectorProperties);
 342     }
 343
 344     override onNodeUpdated(NodeUpdated notification) {
 345         val properties = Collections.<org.opendaylight.controller.sal.core.Property>emptySet();
 346         val InstanceIdentifier<? extends DataObject> identifier = notification.nodeRef.value  as InstanceIdentifier<? extends DataObject>;
 347
 348         var updateType = UpdateType.CHANGED;
 349         if ( this._dataService.readOperationalData(identifier) == null ){
 350             updateType = UpdateType.ADDED;
 351         }
 352         inventoryPublisher.updateNode(notification.nodeRef.toADNode, updateType, properties);
 353
 354                 //Notify the listeners of IPluginOutReadService
 355
 356         for (statsPublisher : statisticsPublisher){
 357                         val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance;
 358                         statsPublisher.descriptionStatisticsUpdated(nodeRef.toADNode,toNodeDescription(notification.nodeRef));
 359                 }
 360     }
 361
 362     override getNodeProps() {
 363
 364         // FIXME: Read from MD-SAL inventory service
 365         return null;
 366     }
 367
 368     override getNodeConnectorProps(Boolean refresh) {
 369
 370         // FIXME: Read from MD-SAL Invcentory Service
 371         return null;
 372     }
 373
 374     private def FlowCapableNode readFlowCapableNode(NodeRef ref) {
 375         val dataObject = dataService.readOperationalData(ref.value as InstanceIdentifier<? extends DataObject>);
 376         val node = dataObject.checkInstanceOf(
 377             org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node);
 378         return node.getAugmentation(FlowCapableNode);
 379     }
 380
 381     private def FlowCapableNodeConnector readFlowCapableNodeConnector(NodeConnectorRef ref) {
 382         val dataObject = dataService.readOperationalData(ref.value as InstanceIdentifier<? extends DataObject>);
 383         val node = dataObject.checkInstanceOf(
 384             NodeConnector);
 385         return node.getAugmentation(FlowCapableNodeConnector);
 386     }
 387
 388     private def toNodeConnectorStatistics(
 389         org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.NodeConnectorStatistics nodeConnectorStatistics, NodeId nodeId, NodeConnectorId nodeConnectorId) {
 390
 391                         val it = new NodeConnectorStatistics();
 392
 393                         receivePacketCount = nodeConnectorStatistics.packets.received.longValue;
 394                         transmitPacketCount = nodeConnectorStatistics.packets.transmitted.longValue;
 395
 396                         receiveByteCount = nodeConnectorStatistics.bytes.received.longValue;
 397                         transmitByteCount = nodeConnectorStatistics.bytes.transmitted.longValue;
 398
 399                         receiveDropCount = nodeConnectorStatistics.receiveDrops.longValue;
 400                         transmitDropCount = nodeConnectorStatistics.transmitDrops.longValue;
 401
 402                         receiveErrorCount = nodeConnectorStatistics.receiveErrors.longValue;
 403                         transmitErrorCount = nodeConnectorStatistics.transmitErrors.longValue;
 404
 405                         receiveFrameErrorCount = nodeConnectorStatistics.receiveFrameError.longValue;
 406                         receiveOverRunErrorCount = nodeConnectorStatistics.receiveOverRunError.longValue;
 407                         receiveCRCErrorCount = nodeConnectorStatistics.receiveCrcError.longValue;
 408                         collisionCount = nodeConnectorStatistics.collisionCount.longValue;
 409
 410                         val nodeConnectorRef = InstanceIdentifier.builder(Nodes)
 411                                                                 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(nodeId))
 412                                                                 .child(NodeConnector,new NodeConnectorKey(nodeConnectorId)).toInstance;
 413
 414                         nodeConnector = NodeMapping.toADNodeConnector(new NodeConnectorRef(nodeConnectorRef));
 415
 416                         return it;
 417     }
 418
 419         private def toNodeTableStatistics(
 420                 FlowTableStatistics tableStats,
 421                 Short tableId,Node node){
 422                 var it = new NodeTableStatistics();
 423
 424                 activeCount = tableStats.activeFlows.value.intValue;
 425                 lookupCount = tableStats.packetsLookedUp.value.intValue;
 426                 matchedCount = tableStats.packetsMatched.value.intValue;
 427                 name = tableId.toString;
 428                 nodeTable = new NodeTable(NodeMapping.MD_SAL_TYPE,tableId,node);
 429                 return it;
 430         }
 431
 432         private def toNodeDescription(NodeRef nodeRef){
 433                 val capableNode = readFlowCapableNode(nodeRef);
 434
 435         val it = new NodeDescription()
 436         manufacturer = capableNode.manufacturer
 437         serialNumber = capableNode.serialNumber
 438         software = capableNode.software
 439         description = capableNode.description
 440
 441         return it;
 442         }
 443
 444
 445     def Edge toADEdge(Link link) {
 446         new Edge(link.source.toADNodeConnector,link.destination.toADNodeConnector)
 447     }
 448
 449         /*
 450          * OpendaylightFlowStatisticsListener interface implementation
 451          */
 452         override onAggregateFlowStatisticsUpdate(AggregateFlowStatisticsUpdate notification) {
 453                 throw new UnsupportedOperationException("TODO: auto-generated method stub")
 454         }
 455
 456         override onFlowsStatisticsUpdate(FlowsStatisticsUpdate notification) {
 457
 458                 val adsalFlowsStatistics = new ArrayList<FlowOnNode>();
 459
 460                 for(flowStats : notification.flowAndStatisticsMapList){
 461                         if(flowStats.tableId == 0)
 462                                 adsalFlowsStatistics.add(toFlowOnNode(flowStats));
 463                 }
 464
 465                 for (statsPublisher : statisticsPublisher){
 466                         val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance;
 467                         statsPublisher.nodeFlowStatisticsUpdated(nodeRef.toADNode,adsalFlowsStatistics);
 468                 }
 469
 470         }
 471         /*
 472          * OpendaylightFlowTableStatisticsListener interface implementation
 473          */
 474         override onFlowTableStatisticsUpdate(FlowTableStatisticsUpdate notification) {
 475                 var adsalFlowTableStatistics = new ArrayList<NodeTableStatistics>();
 476
 477                 for(stats : notification.flowTableAndStatisticsMap){
 478                         if (stats.tableId.value == 0){
 479                                 val it = new NodeTableStatistics();
 480                                 activeCount = stats.activeFlows.value.intValue;
 481                                 lookupCount = stats.packetsLookedUp.value.longValue;
 482                                 matchedCount = stats.packetsMatched.value.longValue;
 483
 484                                 adsalFlowTableStatistics.add(it);
 485                         }
 486                 }
 487                 for (statsPublisher : statisticsPublisher){
 488                         val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance;
 489                         statsPublisher.nodeTableStatisticsUpdated(nodeRef.toADNode,adsalFlowTableStatistics);
 490                 }
 491         }
 492
 493         /*
 494          * OpendaylightPortStatisticsUpdate interface implementation
 495          */
 496         override onNodeConnectorStatisticsUpdate(NodeConnectorStatisticsUpdate notification) {
 497
 498                 val adsalPortStatistics  = new ArrayList<NodeConnectorStatistics>();
 499
 500                 for(nodeConnectorStatistics : notification.nodeConnectorStatisticsAndPortNumberMap){
 501                         adsalPortStatistics.add(toNodeConnectorStatistics(nodeConnectorStatistics,notification.id,nodeConnectorStatistics.nodeConnectorId));
 502                 }
 503
 504                 for (statsPublisher : statisticsPublisher){
 505                         val nodeRef = InstanceIdentifier.builder(Nodes).child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node,new NodeKey(notification.id)).toInstance;
 506                         statsPublisher.nodeConnectorStatisticsUpdated(nodeRef.toADNode,adsalPortStatistics);
 507                 }
 508
 509         }
 510
 511         private static def toFlowOnNode (FlowAndStatisticsMapList flowAndStatsMap){
 512
 513                 val it = new FlowOnNode(ToSalConversionsUtils.toFlow(flowAndStatsMap));
 514
 515                 byteCount = flowAndStatsMap.byteCount.value.longValue;
 516                 packetCount = flowAndStatsMap.packetCount.value.longValue;
 517                 durationSeconds = flowAndStatsMap.duration.second.value.intValue;
 518                 durationNanoseconds = flowAndStatsMap.duration.nanosecond.value.intValue;
 519
 520                 return it;
 521         }
 522 }