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

   1 package org.opendaylight.controller.sal.compability
   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.compability.NodeMapping.*
  12 import static org.opendaylight.controller.sal.compability.MDFlowMapping.*
  13 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow   .inventory.rev130819.FlowCapableNode
  14 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector
  15 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef
  16 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef
  17 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsService
  18 import org.opendaylight.controller.sal.reader.NodeConnectorStatistics
  19 import org.opendaylight.controller.sal.reader.FlowOnNode
  20 import org.opendaylight.controller.sal.reader.NodeDescription
  21 import org.slf4j.LoggerFactory
  22 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowStatisticsInputBuilder
  23 import java.util.ArrayList
  24 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllNodeConnectorStatisticsInputBuilder
  25 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService
  26 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener
  27 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated
  30 import java.util.Collections
  31 import org.opendaylight.controller.sal.core.UpdateType
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated
  34 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier
  35 import org.opendaylight.yangtools.yang.binding.DataObject
  36
  37 class InventoryAndReadAdapter implements IPluginInReadService, IPluginInInventoryService,OpendaylightInventoryListener {
  38
  39     private static val LOG = LoggerFactory.getLogger(InventoryAndReadAdapter);
  40
  41     @Property
  42     DataBrokerService dataService;
  43
  44     @Property
  45     OpendaylightFlowStatisticsService flowStatisticsService;
  46
  47     @Property
  48     IPluginOutInventoryService adInventoryPublisher;
  49
  50
  51     override getTransmitRate(NodeConnector connector) {
  52         val nodeConnector = readFlowCapableNodeConnector(connector.toNodeConnectorRef);
  53         return nodeConnector.currentSpeed
  54     }
  55
  56     override readAllFlow(Node node, boolean cached) {
  57         val input = new GetAllFlowStatisticsInputBuilder;
  58         input.setNode(node.toNodeRef);
  59         val result = flowStatisticsService.getAllFlowStatistics(input.build)
  60
  61         val statistics = result.get.result;
  62         val output = new ArrayList<FlowOnNode>();
  63         for(stat : statistics.flowStatistics) {
  64             // FIXME: Create FlowOnNode
  65         }
  66         return output;
  67     }
  68
  69     override readAllNodeConnector(Node node, boolean cached) {
  70         val input = new GetAllNodeConnectorStatisticsInputBuilder();
  71         input.setNode(node.toNodeRef);
  72         val result = flowStatisticsService.getAllNodeConnectorStatistics(input.build());
  73         val statistics = result.get.result.nodeConnectorStatistics;
  74         val ret = new ArrayList<NodeConnectorStatistics>();
  75         for(stat : statistics) {
  76             ret.add(stat.toNodeConnectorStatistics())
  77         }
  78         return ret;
  79     }
  80
  81     override readAllNodeTable(Node node, boolean cached) {
  82         throw new UnsupportedOperationException("TODO: auto-generated method stub")
  83     }
  84
  85     override readDescription(Node node, boolean cached) {
  86         val capableNode = readFlowCapableNode(node.toNodeRef)
  87
  88         val it = new NodeDescription()
  89         manufacturer = capableNode.manufacturer
  90         serialNumber = capableNode.serialNumber
  91         software = capableNode.software
  92         description = capableNode.description
  93
  94         return it;
  95     }
  96
  97     override readFlow(Node node, Flow flow, boolean cached) {
  98         val input = flowStatisticsInput(node, flow);
  99         val output = flowStatisticsService.getFlowStatistics(input);
 100
 101         try {
 102             val statistics = output.get().getResult();
 103             if (statistics != null) {
 104                 val it = new FlowOnNode(flow);
 105                 byteCount = statistics.byteCount.value.longValue
 106                 durationNanoseconds = statistics.duration.getNanosecond().getValue().intValue();
 107                 durationSeconds = statistics.duration.getSecond().getValue().intValue();
 108                 packetCount = statistics.getPacketCount().getValue().longValue();
 109                 return it;
 110             }
 111         } catch (Exception e) {
 112              LOG.error("Read flow not processed", e);
 113         }
 114         return null;
 115     }
 116
 117     override readNodeConnector(NodeConnector connector, boolean cached) {
 118
 119         val getNodeConnectorStatisticsInput = FromSalConversionsUtils.nodeConnectorStatistics(connector);
 120         val future = flowStatisticsService.getNodeConnectorStatistics(getNodeConnectorStatisticsInput);
 121         try {
 122             val rpcResult = future.get();
 123             val output = rpcResult.getResult();
 124
 125             if (output != null) {
 126                 return output.toNodeConnectorStatistics;
 127             }
 128         } catch (Exception e) {
 129             LOG.error("Read node connector not processed", e);
 130         }
 131
 132         return null;
 133     }
 134
 135     override onNodeConnectorRemoved(NodeConnectorRemoved update) {
 136         // NOOP
 137     }
 138
 139     override onNodeRemoved(NodeRemoved notification) {
 140
 141         // NOOP
 142     }
 143
 144     override onNodeConnectorUpdated(NodeConnectorUpdated update) {
 145         val properties = Collections.<org.opendaylight.controller.sal.core.Property>emptySet();
 146         adInventoryPublisher.updateNodeConnector(update.nodeConnectorRef.toADNodeConnector,UpdateType.CHANGED,properties);
 147     }
 148
 149     override onNodeUpdated(NodeUpdated notification) {
 150         val properties = Collections.<org.opendaylight.controller.sal.core.Property>emptySet();
 151         adInventoryPublisher.updateNode(notification.nodeRef.toADNode,UpdateType.CHANGED,properties);
 152     }
 153
 154     override  getNodeProps() {
 155         // FIXME: Read from MD-SAL inventory service
 156         return null;
 157     }
 158
 159     override  getNodeConnectorProps(Boolean refresh) {
 160         // FIXME: Read from MD-SAL Invcentory Service
 161         return null;
 162     }
 163
 164
 165     override readNodeTable(NodeTable table, boolean cached) {
 166         throw new UnsupportedOperationException("TODO: auto-generated method stub")
 167     }
 168
 169     private def FlowCapableNode readFlowCapableNode(NodeRef ref) {
 170         val dataObject = dataService.readOperationalData(ref.value as InstanceIdentifier<? extends DataObject>);
 171         val node = dataObject.checkInstanceOf(
 172             org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node);
 173         return node.getAugmentation(FlowCapableNode);
 174     }
 175
 176     private def FlowCapableNodeConnector readFlowCapableNodeConnector(NodeConnectorRef ref) {
 177         val dataObject = dataService.readOperationalData(ref.value as InstanceIdentifier<? extends DataObject>);
 178         val node = dataObject.checkInstanceOf(
 179             org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector);
 180         return node.getAugmentation(FlowCapableNodeConnector);
 181     }
 182
 183     private static def toNodeConnectorStatistics(
 184         org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.NodeConnectorStatistics output) {
 185         val it = new NodeConnectorStatistics
 186
 187         collisionCount = output.getCollisionCount().longValue();
 188         receiveCRCErrorCount = output.getReceiveCrcError().longValue();
 189         receiveFrameErrorCount = output.getReceiveFrameError().longValue();
 190         receiveOverRunErrorCount = output.getReceiveOverRunError().longValue();
 191
 192         receiveDropCount = output.getReceiveDrops().longValue();
 193         receiveErrorCount = output.getReceiveErrors().longValue();
 194         receivePacketCount = output.getPackets().getReceived().longValue();
 195         receiveByteCount = output.getBytes().getReceived().longValue();
 196
 197         transmitDropCount = output.getTransmitDrops().longValue();
 198         transmitErrorCount = output.getTransmitErrors().longValue();
 199         transmitPacketCount = output.getPackets().getTransmitted().longValue();
 200         transmitByteCount = output.getBytes().getTransmitted().longValue();
 201         return it;
 202     }
 203 }