opendaylight/md-sal/sal-compability/src/main/java/org/opendaylight/controller/sal/compability/adsal/FlowStatisticsAdapter.java

   1 package org.opendaylight.controller.sal.compability.adsal;
   2
   3 import java.math.BigInteger;
   4 import java.util.ArrayList;
   5 import java.util.List;
   6 import java.util.concurrent.Future;
   7
   8 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
   9 import org.opendaylight.controller.sal.common.util.Futures;
  10 import org.opendaylight.controller.sal.common.util.Rpcs;
  11 import org.opendaylight.controller.sal.compability.NodeMapping;
  12 import org.opendaylight.controller.sal.compability.ToSalConversionsUtils;
  13 import org.opendaylight.controller.sal.core.ConstructionException;
  14 import org.opendaylight.controller.sal.core.Node;
  15 import org.opendaylight.controller.sal.flowprogrammer.Flow;
  16 import org.opendaylight.controller.sal.reader.*;
  17 import org.opendaylight.yang.gen.v1.urn.ietf.params.xml.ns.yang.ietf.yang.types.rev100924.Counter64;
  18 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.*;
  19 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.flow.statistics.output.FlowStatistics;
  20 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.flow.statistics.output.FlowStatisticsBuilder;
  21 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatisticsBuilder;
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.statistics.Duration;
  23 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev131026.flow.statistics.DurationBuilder;
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
  25 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Bytes;
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.BytesBuilder;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Packets;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.PacketsBuilder;
  29 import org.opendaylight.yangtools.yang.common.RpcResult;
  30 import org.slf4j.Logger;
  31 import org.slf4j.LoggerFactory;
  32
  33 public class FlowStatisticsAdapter implements OpendaylightFlowStatisticsService, IReadServiceListener {
  34
  35     private static final Logger LOG = LoggerFactory.getLogger(FlowStatisticsAdapter.class);
  36     private IReadService readDelegate;
  37     private NotificationProviderService notifier;
  38
  39     @Override
  40     public Future<RpcResult<GetAllFlowStatisticsOutput>> getAllFlowStatistics(GetAllFlowStatisticsInput input) {
  41         GetAllFlowStatisticsOutput rpcResultType = null;
  42         boolean rpcResultBool = false;
  43
  44         try {
  45             Node adNode = NodeMapping.toADNode(input.getNode());
  46             List<FlowOnNode> flowsOnNode = readDelegate.readAllFlows(adNode);
  47             List<FlowStatistics> flowsStatistics = toOdFlowsStatistics(flowsOnNode);
  48             GetAllFlowStatisticsOutputBuilder builder = new GetAllFlowStatisticsOutputBuilder();
  49             rpcResultType = builder.setFlowStatistics(flowsStatistics).build();
  50             rpcResultBool = true;
  51         } catch (ConstructionException e) {
  52             LOG.error(e.getMessage());
  53         }
  54
  55         return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null));
  56     }
  57
  58     @Override
  59     public Future<RpcResult<GetAllNodeConnectorStatisticsOutput>> getAllNodeConnectorStatistics(
  60             GetAllNodeConnectorStatisticsInput input) {
  61         GetAllNodeConnectorStatisticsOutput rpcResultType = null;
  62         boolean rpcResultBool = false;
  63
  64         try {
  65             Node adNode = NodeMapping.toADNode(input.getNode());
  66             List<NodeConnectorStatistics> nodesConnectorStatistics = readDelegate.readNodeConnectors(adNode);
  67             List<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics> odNodesConnectorStatistics;
  68             odNodesConnectorStatistics = toOdNodesConnectorStatistics(nodesConnectorStatistics);
  69             GetAllNodeConnectorStatisticsOutputBuilder builder = new GetAllNodeConnectorStatisticsOutputBuilder();
  70             rpcResultType = builder.setNodeConnectorStatistics(odNodesConnectorStatistics).build();
  71             rpcResultBool = true;
  72         } catch (ConstructionException e) {
  73             LOG.error(e.getMessage());
  74         }
  75
  76         return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null));
  77     }
  78
  79     @Override
  80     public Future<RpcResult<GetFlowStatisticsOutput>> getFlowStatistics(GetFlowStatisticsInput input) {
  81         GetFlowStatisticsOutput rpcResultType = null;
  82         boolean rpcResultBool = false;
  83
  84         try {
  85             Node node = NodeMapping.toADNode(input.getNode());
  86             Flow flow = ToSalConversionsUtils.toFlow(input);
  87             FlowOnNode readFlow = readDelegate.readFlow(node, flow);
  88             FlowStatistics flowOnNodeToFlowStatistics = toOdFlowStatistics(readFlow);
  89             rpcResultType = new GetFlowStatisticsOutputBuilder(flowOnNodeToFlowStatistics).build();
  90             rpcResultBool = true;
  91         } catch (ConstructionException e) {
  92             LOG.error(e.getMessage());
  93         }
  94
  95         return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null));
  96     }
  97
  98     @Override
  99     public Future<RpcResult<GetFlowTableStatisticsOutput>> getFlowTableStatistics(GetFlowTableStatisticsInput input) {
 100         GetFlowTableStatisticsOutput rpcResultType = null;
 101         boolean rpcResultBool = false;
 102
 103         try {
 104             Node node = NodeMapping.toADNode(input.getNode());
 105             List<NodeTableStatistics> nodesTable = readDelegate.readNodeTable(node);
 106             NodeTableStatistics nodeTable = null;
 107             if (!nodesTable.isEmpty()) {
 108                 nodeTable = nodesTable.get(0);
 109                 rpcResultType = toOdTableStatistics(nodeTable);
 110                 rpcResultBool = true;
 111             }
 112         } catch (ConstructionException e) {
 113             LOG.error(e.getMessage());
 114         }
 115
 116         return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null));
 117     }
 118
 119     @Override
 120     public Future<RpcResult<GetNodeConnectorStatisticsOutput>> getNodeConnectorStatistics(
 121             GetNodeConnectorStatisticsInput input) {
 122         GetNodeConnectorStatisticsOutput rpcResultType = null;
 123         boolean rpcResultBool = false;
 124
 125         NodeConnectorRef nodeConnector = input.getNodeConnector();
 126         try {
 127             NodeConnectorStatistics nodeConnectorStats = readDelegate.readNodeConnector(NodeMapping
 128                     .toADNodeConnector(nodeConnector));
 129             org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics odNodeConnectorStatistics = toOdNodeConnectorStatistics(nodeConnectorStats);
 130             rpcResultType = new GetNodeConnectorStatisticsOutputBuilder(odNodeConnectorStatistics).build();
 131             rpcResultBool = true;
 132         } catch (ConstructionException e) {
 133             LOG.error(e.getMessage());
 134         }
 135
 136         return Futures.immediateFuture(Rpcs.getRpcResult(rpcResultBool, rpcResultType, null));
 137     }
 138
 139     @Override
 140     public void descriptionStatisticsUpdated(Node node, NodeDescription nodeDescription) {
 141
 142         // TODO which *StatisticsUpdated interface should be used?
 143
 144     }
 145
 146     @Override
 147     public void nodeConnectorStatisticsUpdated(Node node, List<NodeConnectorStatistics> ncStatsList) {
 148         for (NodeConnectorStatistics ndConStats : ncStatsList) {
 149             org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics odNodeConnectorStatistics;
 150             odNodeConnectorStatistics = toOdNodeConnectorStatistics(ndConStats);
 151             NodeConnectorStatisticsUpdatedBuilder statisticsBuilder = new NodeConnectorStatisticsUpdatedBuilder(
 152                     odNodeConnectorStatistics);
 153             notifier.publish(statisticsBuilder.build());
 154         }
 155     }
 156
 157     @Override
 158     public void nodeFlowStatisticsUpdated(Node node, List<FlowOnNode> flowStatsList) {
 159         for (FlowOnNode flowOnNode : flowStatsList) {
 160             FlowStatistics flowStatistics = toOdFlowStatistics(flowOnNode);
 161             FlowStatisticsUpdatedBuilder statisticsBuilder = new FlowStatisticsUpdatedBuilder(flowStatistics);
 162             notifier.publish(statisticsBuilder.build());
 163         }
 164     }
 165
 166     @Override
 167     public void nodeTableStatisticsUpdated(Node node, List<NodeTableStatistics> tableStatsList) {
 168         // TODO : Not implemented by AD-SAL.
 169     }
 170
 171     private List<FlowStatistics> toOdFlowsStatistics(List<FlowOnNode> flowsOnNode) {
 172         List<FlowStatistics> flowsStatistics = new ArrayList<>();
 173         for (FlowOnNode flowOnNode : flowsOnNode) {
 174             flowsStatistics.add(toOdFlowStatistics(flowOnNode));
 175         }
 176         return flowsStatistics;
 177     }
 178
 179     private FlowStatistics toOdFlowStatistics(FlowOnNode flowOnNode) {
 180         FlowStatisticsBuilder builder = new FlowStatisticsBuilder();
 181
 182         builder.setByteCount(toCounter64(flowOnNode.getByteCount()));
 183         builder.setPacketCount(toCounter64(flowOnNode.getPacketCount()));
 184         builder.setDuration(extractDuration(flowOnNode));
 185
 186         return builder.build();
 187     }
 188
 189     private Duration extractDuration(FlowOnNode flowOnNode) {
 190         DurationBuilder builder = new DurationBuilder();
 191         builder.setNanosecond(toCounter64(flowOnNode.getDurationNanoseconds()));
 192         builder.setSecond(toCounter64(flowOnNode.getDurationSeconds()));
 193         return builder.build();
 194     }
 195
 196     private Counter64 toCounter64(long num) {
 197         String byteCountStr = String.valueOf(num);
 198         BigInteger byteCountBigInt = new BigInteger(byteCountStr);
 199         return new Counter64(byteCountBigInt);
 200     }
 201
 202     private Counter64 toCounter64(int num) {
 203         String byteCountStr = String.valueOf(num);
 204         BigInteger byteCountBigInt = new BigInteger(byteCountStr);
 205         return new Counter64(byteCountBigInt);
 206     }
 207
 208     private List<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics> toOdNodesConnectorStatistics(
 209             List<NodeConnectorStatistics> nodesConnectorStatistics) {
 210         List<org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics> odNodesConnectorStatistics = new ArrayList<>();
 211         for (NodeConnectorStatistics nodeConnectorStatistics : nodesConnectorStatistics) {
 212             odNodesConnectorStatistics.add(toOdNodeConnectorStatistics(nodeConnectorStatistics));
 213         }
 214         return odNodesConnectorStatistics;
 215     }
 216
 217     private org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.get.all.node.connector.statistics.output.NodeConnectorStatistics toOdNodeConnectorStatistics(
 218             NodeConnectorStatistics ndConStats) {
 219         NodeConnectorStatisticsBuilder builder = new NodeConnectorStatisticsBuilder();
 220
 221         builder.setBytes(extractBytes(ndConStats));
 222         builder.setCollisionCount(toBI(ndConStats.getCollisionCount()));
 223         builder.setDuration(null);
 224         builder.setPackets(extractPackets(ndConStats));
 225         builder.setReceiveCrcError(toBI(ndConStats.getReceiveCRCErrorCount()));
 226         builder.setReceiveDrops(toBI(ndConStats.getReceiveDropCount()));
 227         builder.setReceiveErrors(toBI(ndConStats.getReceiveErrorCount()));
 228         builder.setReceiveFrameError(toBI(ndConStats.getReceiveFrameErrorCount()));
 229         builder.setReceiveOverRunError(toBI(ndConStats.getReceiveOverRunErrorCount()));
 230         builder.setTransmitDrops(toBI(ndConStats.getTransmitDropCount()));
 231         builder.setTransmitErrors(toBI(ndConStats.getTransmitErrorCount()));
 232
 233         return builder.build();
 234     }
 235
 236     private BigInteger toBI(long num) {
 237         String numStr = String.valueOf(num);
 238         return new BigInteger(numStr);
 239     }
 240
 241     private Packets extractPackets(NodeConnectorStatistics nodeConnectorStatistics) {
 242         long receivePacketCount = nodeConnectorStatistics.getReceivePacketCount();
 243         long transmitPacketCount = nodeConnectorStatistics.getTransmitPacketCount();
 244
 245         PacketsBuilder builder = new PacketsBuilder();
 246         builder.setReceived(toBI(receivePacketCount));
 247         builder.setTransmitted(toBI(transmitPacketCount));
 248
 249         return builder.build();
 250     }
 251
 252     private Bytes extractBytes(NodeConnectorStatistics nodeConnectorStatistics) {
 253         long transmitByteCount = nodeConnectorStatistics.getTransmitByteCount();
 254         long receiveByteCount = nodeConnectorStatistics.getReceiveByteCount();
 255
 256         BytesBuilder builder = new BytesBuilder();
 257         builder.setReceived(toBI(receiveByteCount));
 258         builder.setTransmitted(toBI(transmitByteCount));
 259
 260         return builder.build();
 261     }
 262
 263     private GetFlowTableStatisticsOutput toOdTableStatistics(NodeTableStatistics nodeTable) {
 264         GetFlowTableStatisticsOutputBuilder builder = new GetFlowTableStatisticsOutputBuilder();
 265
 266         builder.setActive(toCounter64(nodeTable.getActiveCount()));
 267         builder.setLookup(toCounter64(nodeTable.getLookupCount()));
 268         builder.setMatched(toCounter64(nodeTable.getMatchedCount()));
 269
 270         return builder.build();
 271     }
 272
 273 }