opendaylight/md-sal/sal-compability/src/main/java/org/opendaylight/controller/sal/compability/impl/MdOpendaylightFlowStatisticsServiceAdapter.java

   1 package org.opendaylight.controller.sal.compability.impl;
   2
   3 import java.util.List;
   4 import java.util.concurrent.ExecutionException;
   5 import java.util.concurrent.Future;
   6
   7 import org.opendaylight.controller.sal.compability.FromSalConversionsUtils;
   8 import org.opendaylight.controller.sal.core.Node;
   9 import org.opendaylight.controller.sal.core.NodeConnector;
  10 import org.opendaylight.controller.sal.core.NodeTable;
  11 import org.opendaylight.controller.sal.flowprogrammer.Flow;
  12 import org.opendaylight.controller.sal.reader.*;
  13 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.*;
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.rev130819.flow.statistics.Duration;
  15 import org.opendaylight.yangtools.yang.common.RpcResult;
  16 import org.slf4j.Logger;
  17 import org.slf4j.LoggerFactory;
  18
  19 public class MdOpendaylightFlowStatisticsServiceAdapter implements IPluginInReadService {
  20
  21     private static final Logger LOG = LoggerFactory.getLogger(MdOpendaylightFlowStatisticsServiceAdapter.class);
  22     private OpendaylightFlowStatisticsService opendaylightFlowStatisticsService;
  23
  24     @Override
  25     public FlowOnNode readFlow(Node node, Flow flow, boolean cached) {
  26         FlowOnNode result = null;
  27
  28         GetFlowStatisticsInput getFlowStatisticsInput = FromSalConversionsUtils.flowStatisticsInput(node,flow);
  29         Future<RpcResult<GetFlowStatisticsOutput>> futureStatisticsOutput = opendaylightFlowStatisticsService
  30                 .getFlowStatistics(getFlowStatisticsInput);
  31
  32         RpcResult<GetFlowStatisticsOutput> rpcResultStatisticsOutput;
  33         GetFlowStatisticsOutput getFlowStatisticsOutput;
  34         try {
  35             rpcResultStatisticsOutput = futureStatisticsOutput.get();
  36             if (rpcResultStatisticsOutput != null) {
  37                 getFlowStatisticsOutput = rpcResultStatisticsOutput.getResult();
  38                 if (getFlowStatisticsOutput != null) {
  39
  40                     long byteCount = getFlowStatisticsOutput.getByteCount().getValue().longValue();
  41
  42                     Duration duration = getFlowStatisticsOutput.getDuration();
  43                     int nanoseconds = duration.getNanosecond().getValue().intValue();
  44                     int seconds = duration.getSecond().getValue().intValue();
  45                     long packetCount = getFlowStatisticsOutput.getPacketCount().getValue().longValue();
  46
  47                     result = new FlowOnNode(flow);
  48                     result.setByteCount(byteCount);
  49                     result.setDurationNanoseconds(nanoseconds);
  50                     result.setDurationSeconds(seconds);
  51                     result.setPacketCount(packetCount);
  52                     return result;
  53                 }
  54             }
  55         } catch (InterruptedException | ExecutionException e) {
  56             LOG.error("Read flow not processed", e);
  57         }
  58         return null;
  59     }
  60
  61     @Override
  62     public List<FlowOnNode> readAllFlow(Node node, boolean cached) {
  63         // TODO Auto-generated method stub
  64         return null;
  65     }
  66
  67     @Override
  68     public NodeDescription readDescription(Node node, boolean cached) {
  69         // TODO Auto-generated method stub
  70         return null;
  71     }
  72
  73     @Override
  74     public NodeConnectorStatistics readNodeConnector(NodeConnector connector, boolean cached) {
  75         NodeConnectorStatistics result = null;
  76         GetNodeConnectorStatisticsInput getNodeConnectorStatisticsInput = FromSalConversionsUtils
  77                 .nodeConnectorStatistics(connector);
  78         Future<RpcResult<GetNodeConnectorStatisticsOutput>> future = opendaylightFlowStatisticsService
  79                 .getNodeConnectorStatistics(getNodeConnectorStatisticsInput);
  80         try {
  81             RpcResult<GetNodeConnectorStatisticsOutput> rpcResult = future.get();
  82             if (rpcResult != null) {
  83                 GetNodeConnectorStatisticsOutput getNodeConnectorStatisticsOutput = rpcResult.getResult();
  84
  85                 if (getNodeConnectorStatisticsOutput != null) {
  86                     result = new NodeConnectorStatistics();
  87
  88                     long colisionCount = getNodeConnectorStatisticsOutput.getCollisionCount().longValue();
  89                     long receiveCrcErrorCount = getNodeConnectorStatisticsOutput.getReceiveCrcError().longValue();
  90                     long receiveFrameErrorCount = getNodeConnectorStatisticsOutput.getReceiveFrameError().longValue();
  91                     long receiveOverRunError = getNodeConnectorStatisticsOutput.getReceiveOverRunError().longValue();
  92
  93                     long receiveDropCount = getNodeConnectorStatisticsOutput.getReceiveDrops().longValue();
  94                     long receiveErrorCount = getNodeConnectorStatisticsOutput.getReceiveErrors().longValue();
  95                     long receivePacketCount = getNodeConnectorStatisticsOutput.getPackets().getReceived().longValue();
  96                     long receivedByteCount = getNodeConnectorStatisticsOutput.getBytes().getReceived().longValue();
  97
  98                     long transmitDropCount = getNodeConnectorStatisticsOutput.getTransmitDrops().longValue();
  99                     long transmitErrorCount = getNodeConnectorStatisticsOutput.getTransmitErrors().longValue();
 100                     long transmitPacketCount = getNodeConnectorStatisticsOutput.getPackets().getTransmitted()
 101                             .longValue();
 102                     long transmitByteCount = getNodeConnectorStatisticsOutput.getBytes().getTransmitted().longValue();
 103
 104                     result.setCollisionCount(colisionCount);
 105                     result.setReceiveByteCount(receivedByteCount);
 106                     result.setReceiveCRCErrorCount(receiveCrcErrorCount);
 107                     result.setReceiveDropCount(receiveDropCount);
 108                     result.setReceiveErrorCount(receiveErrorCount);
 109                     result.setReceiveFrameErrorCount(receiveFrameErrorCount);
 110                     result.setReceiveOverRunErrorCount(receiveOverRunError);
 111                     result.setReceivePacketCount(receivePacketCount);
 112                     result.setTransmitByteCount(transmitByteCount);
 113                     result.setTransmitDropCount(transmitDropCount);
 114                     result.setTransmitErrorCount(transmitErrorCount);
 115                     result.setTransmitPacketCount(transmitPacketCount);
 116                     return result;
 117                 }
 118             }
 119         } catch (InterruptedException | ExecutionException e) {
 120             LOG.error("Read node connector not processed", e);
 121         }
 122
 123         return result;
 124
 125     }
 126
 127     @Override
 128     public List<NodeConnectorStatistics> readAllNodeConnector(Node node, boolean cached) {
 129         // TODO Auto-generated method stub
 130         return null;
 131     }
 132
 133     @Override
 134     public NodeTableStatistics readNodeTable(NodeTable table, boolean cached) {
 135         // TODO Auto-generated method stub
 136         return null;
 137     }
 138
 139     @Override
 140     public List<NodeTableStatistics> readAllNodeTable(Node node, boolean cached) {
 141         // TODO Auto-generated method stub
 142         return null;
 143     }
 144
 145     @Override
 146     public long getTransmitRate(NodeConnector connector) {
 147         // TODO Auto-generated method stub
 148         return 0;
 149     }
 150
 151     public OpendaylightFlowStatisticsService getOpendaylightFlowStatisticsService() {
 152         return opendaylightFlowStatisticsService;
 153     }
 154
 155     public void setOpendaylightFlowStatisticsService(OpendaylightFlowStatisticsService opendaylightFlowStatisticsService) {
 156         this.opendaylightFlowStatisticsService = opendaylightFlowStatisticsService;
 157     }
 158
 159 }