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