+ }
+
+ trans.commit();
+ }
+
+
+ public synchronized void updateMeterStats(List<MeterStats> list) {
+ final DataModificationTransaction trans = statisticsProvider.startChange();
+
+ for(MeterStats meterStats : list) {
+ MeterBuilder meterBuilder = new MeterBuilder();
+ MeterKey meterKey = new MeterKey(meterStats.getMeterId());
+ meterBuilder.setKey(meterKey);
+
+ InstanceIdentifier<Meter> meterRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, targetNodeKey)
+ .augmentation(FlowCapableNode.class)
+ .child(Meter.class,meterKey).toInstance();
+
+ NodeMeterStatisticsBuilder meterStatsBuilder= new NodeMeterStatisticsBuilder();
+ MeterStatisticsBuilder stats = new MeterStatisticsBuilder();
+ stats.fieldsFrom(meterStats);
+ meterStatsBuilder.setMeterStatistics(stats.build());
+
+ //Update augmented data
+ meterBuilder.addAugmentation(NodeMeterStatistics.class, meterStatsBuilder.build());
+ trans.putOperationalData(meterRef, meterBuilder.build());
+
+ // FIXME: should we be tracking this data?
+ }
+
+ trans.commit();
+ }
+
+ public synchronized void updateQueueStats(List<QueueIdAndStatisticsMap> list) {
+ final Long expiryTime = getExpiryTime();
+ final DataModificationTransaction trans = statisticsProvider.startChange();
+
+ for (QueueIdAndStatisticsMap swQueueStats : list) {
+
+ QueueEntry queueEntry = new QueueEntry(swQueueStats.getNodeConnectorId(),swQueueStats.getQueueId());
+
+ FlowCapableNodeConnectorQueueStatisticsDataBuilder queueStatisticsDataBuilder = new FlowCapableNodeConnectorQueueStatisticsDataBuilder();
+
+ FlowCapableNodeConnectorQueueStatisticsBuilder queueStatisticsBuilder = new FlowCapableNodeConnectorQueueStatisticsBuilder();
+
+ queueStatisticsBuilder.fieldsFrom(swQueueStats);
+
+ queueStatisticsDataBuilder.setFlowCapableNodeConnectorQueueStatistics(queueStatisticsBuilder.build());
+
+ InstanceIdentifier<Queue> queueRef
+ = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, targetNodeKey)
+ .child(NodeConnector.class, new NodeConnectorKey(swQueueStats.getNodeConnectorId()))
+ .augmentation(FlowCapableNodeConnector.class)
+ .child(Queue.class, new QueueKey(swQueueStats.getQueueId())).toInstance();
+
+ QueueBuilder queueBuilder = new QueueBuilder();
+ FlowCapableNodeConnectorQueueStatisticsData qsd = queueStatisticsDataBuilder.build();
+ queueBuilder.addAugmentation(FlowCapableNodeConnectorQueueStatisticsData.class, qsd);
+ queueBuilder.setKey(new QueueKey(swQueueStats.getQueueId()));
+
+ logger.debug("Augmenting queue statistics {} of queue {} to port {}",
+ qsd,
+ swQueueStats.getQueueId(),
+ swQueueStats.getNodeConnectorId());
+
+ trans.putOperationalData(queueRef, queueBuilder.build());
+ this.queuesStatsUpdate.put(queueEntry, expiryTime);
+ }
+
+ trans.commit();
+ }
+
+ public synchronized void updateFlowTableStats(List<FlowTableAndStatisticsMap> list) {
+ final DataModificationTransaction trans = statisticsProvider.startChange();
+
+ for (FlowTableAndStatisticsMap ftStats : list) {
+
+ InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, targetNodeKey)
+ .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(ftStats.getTableId().getValue())).toInstance();
+
+ FlowTableStatisticsDataBuilder statisticsDataBuilder = new FlowTableStatisticsDataBuilder();
+
+ FlowTableStatisticsBuilder statisticsBuilder = new FlowTableStatisticsBuilder();
+ statisticsBuilder.setActiveFlows(ftStats.getActiveFlows());
+ statisticsBuilder.setPacketsLookedUp(ftStats.getPacketsLookedUp());
+ statisticsBuilder.setPacketsMatched(ftStats.getPacketsMatched());
+
+ final FlowTableStatistics stats = statisticsBuilder.build();
+ statisticsDataBuilder.setFlowTableStatistics(stats);
+
+ logger.debug("Augment flow table statistics: {} for table {} on Node {}",
+ stats,ftStats.getTableId(), targetNodeKey);
+
+ TableBuilder tableBuilder = new TableBuilder();
+ tableBuilder.setKey(new TableKey(ftStats.getTableId().getValue()));
+ tableBuilder.addAugmentation(FlowTableStatisticsData.class, statisticsDataBuilder.build());
+ trans.putOperationalData(tableRef, tableBuilder.build());
+
+ // FIXME: should we be tracking this data?
+ }
+
+ trans.commit();
+ }
+
+ public synchronized void updateNodeConnectorStats(List<NodeConnectorStatisticsAndPortNumberMap> list) {
+ final DataModificationTransaction trans = statisticsProvider.startChange();
+
+ for(NodeConnectorStatisticsAndPortNumberMap portStats : list) {
+
+ FlowCapableNodeConnectorStatisticsBuilder statisticsBuilder
+ = new FlowCapableNodeConnectorStatisticsBuilder();
+ statisticsBuilder.setBytes(portStats.getBytes());
+ statisticsBuilder.setCollisionCount(portStats.getCollisionCount());
+ statisticsBuilder.setDuration(portStats.getDuration());
+ statisticsBuilder.setPackets(portStats.getPackets());
+ statisticsBuilder.setReceiveCrcError(portStats.getReceiveCrcError());
+ statisticsBuilder.setReceiveDrops(portStats.getReceiveDrops());
+ statisticsBuilder.setReceiveErrors(portStats.getReceiveErrors());
+ statisticsBuilder.setReceiveFrameError(portStats.getReceiveFrameError());
+ statisticsBuilder.setReceiveOverRunError(portStats.getReceiveOverRunError());
+ statisticsBuilder.setTransmitDrops(portStats.getTransmitDrops());
+ statisticsBuilder.setTransmitErrors(portStats.getTransmitErrors());
+
+ //Augment data to the node-connector
+ FlowCapableNodeConnectorStatisticsDataBuilder statisticsDataBuilder =
+ new FlowCapableNodeConnectorStatisticsDataBuilder();
+
+ statisticsDataBuilder.setFlowCapableNodeConnectorStatistics(statisticsBuilder.build());
+
+ InstanceIdentifier<NodeConnector> nodeConnectorRef = InstanceIdentifier.builder(Nodes.class)
+ .child(Node.class, targetNodeKey)
+ .child(NodeConnector.class, new NodeConnectorKey(portStats.getNodeConnectorId())).toInstance();
+
+ // FIXME: can we bypass this read?
+ NodeConnector nodeConnector = (NodeConnector)trans.readOperationalData(nodeConnectorRef);
+ if(nodeConnector != null){
+ final FlowCapableNodeConnectorStatisticsData stats = statisticsDataBuilder.build();
+ logger.debug("Augmenting port statistics {} to port {}",stats,nodeConnectorRef.toString());
+ NodeConnectorBuilder nodeConnectorBuilder = new NodeConnectorBuilder();
+ nodeConnectorBuilder.addAugmentation(FlowCapableNodeConnectorStatisticsData.class, stats);
+ trans.putOperationalData(nodeConnectorRef, nodeConnectorBuilder.build());
+ }
+
+ // FIXME: should we be tracking this data?
+ }
+
+ trans.commit();
+ }
+
+ public synchronized void updateAggregateFlowStats(Short tableId, AggregateFlowStatistics flowStats) {
+ if (tableId != null) {
+ final DataModificationTransaction trans = statisticsProvider.startChange();
+
+
+ InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class).child(Node.class, targetNodeKey)
+ .augmentation(FlowCapableNode.class).child(Table.class, new TableKey(tableId)).toInstance();
+
+ AggregateFlowStatisticsDataBuilder aggregateFlowStatisticsDataBuilder = new AggregateFlowStatisticsDataBuilder();
+ AggregateFlowStatisticsBuilder aggregateFlowStatisticsBuilder = new AggregateFlowStatisticsBuilder(flowStats);
+
+ aggregateFlowStatisticsDataBuilder.setAggregateFlowStatistics(aggregateFlowStatisticsBuilder.build());
+
+ logger.debug("Augment aggregate statistics: {} for table {} on Node {}",
+ aggregateFlowStatisticsBuilder.build().toString(),tableId,targetNodeKey);
+
+ TableBuilder tableBuilder = new TableBuilder();
+ tableBuilder.setKey(new TableKey(tableId));
+ tableBuilder.addAugmentation(AggregateFlowStatisticsData.class, aggregateFlowStatisticsDataBuilder.build());
+ trans.putOperationalData(tableRef, tableBuilder.build());
+
+ // FIXME: should we be tracking this data?
+ trans.commit();
+ }
+ }
+
+ public synchronized void updateGroupFeatures(GroupFeatures notification) {
+ final DataModificationTransaction trans = statisticsProvider.startChange();
+
+ final NodeBuilder nodeData = new NodeBuilder();
+ nodeData.setKey(targetNodeKey);
+
+ NodeGroupFeaturesBuilder nodeGroupFeatures = new NodeGroupFeaturesBuilder();
+ GroupFeaturesBuilder groupFeatures = new GroupFeaturesBuilder(notification);
+ nodeGroupFeatures.setGroupFeatures(groupFeatures.build());
+
+ //Update augmented data
+ nodeData.addAugmentation(NodeGroupFeatures.class, nodeGroupFeatures.build());
+ trans.putOperationalData(targetNodeIdentifier, nodeData.build());
+
+ // FIXME: should we be tracking this data?
+ trans.commit();
+ }
+
+ public synchronized void updateMeterFeatures(MeterFeatures features) {
+ final DataModificationTransaction trans = statisticsProvider.startChange();
+
+ final NodeBuilder nodeData = new NodeBuilder();
+ nodeData.setKey(targetNodeKey);
+
+ NodeMeterFeaturesBuilder nodeMeterFeatures = new NodeMeterFeaturesBuilder();
+ MeterFeaturesBuilder meterFeature = new MeterFeaturesBuilder(features);
+ nodeMeterFeatures.setMeterFeatures(meterFeature.build());
+
+ //Update augmented data
+ nodeData.addAugmentation(NodeMeterFeatures.class, nodeMeterFeatures.build());
+ trans.putOperationalData(targetNodeIdentifier, nodeData.build());
+
+ // FIXME: should we be tracking this data?
+ trans.commit();