2 * Copyright (c) 2014 Cisco Systems, Inc. and others. All rights reserved.
4 * This program and the accompanying materials are made available under the
5 * terms of the Eclipse Public License v1.0 which accompanies this distribution,
6 * and is available at http://www.eclipse.org/legal/epl-v10.html
8 package org.opendaylight.controller.sal.compatibility;
10 import java.util.ArrayList;
11 import java.util.Collections;
12 import java.util.HashSet;
13 import java.util.List;
16 import java.util.concurrent.ConcurrentHashMap;
17 import java.util.concurrent.ConcurrentMap;
18 import java.util.concurrent.CopyOnWriteArrayList;
20 import org.opendaylight.controller.md.sal.binding.util.TypeSafeDataReader;
21 import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
22 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
23 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
24 import org.opendaylight.controller.sal.core.ConstructionException;
25 import org.opendaylight.controller.sal.core.Edge;
26 import org.opendaylight.controller.sal.core.Node;
27 import org.opendaylight.controller.sal.core.NodeConnector;
28 import org.opendaylight.controller.sal.core.NodeTable;
29 import org.opendaylight.controller.sal.core.NodeTable.NodeTableIDType;
30 import org.opendaylight.controller.sal.core.Property;
31 import org.opendaylight.controller.sal.core.UpdateType;
32 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
33 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService;
34 import org.opendaylight.controller.sal.reader.FlowOnNode;
35 import org.opendaylight.controller.sal.reader.IPluginInReadService;
36 import org.opendaylight.controller.sal.reader.IPluginOutReadService;
37 import org.opendaylight.controller.sal.reader.NodeConnectorStatistics;
38 import org.opendaylight.controller.sal.reader.NodeDescription;
39 import org.opendaylight.controller.sal.reader.NodeTableStatistics;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdate;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdate;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowsStatisticsFromAllFlowTablesInputBuilder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableInputBuilder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsListener;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsService;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsUpdate;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.GetFlowTablesStatisticsInputBuilder;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsListener;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsService;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.and.statistics.map.FlowTableAndStatisticsMap;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.statistics.FlowTableStatistics;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryService;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.Link;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.GenericStatistics;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Bytes;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Packets;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatistics;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllNodeConnectorsStatisticsInputBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetNodeConnectorStatisticsInputBuilder;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.NodeConnectorStatisticsUpdate;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsListener;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService;
84 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap;
85 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
86 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
87 import org.slf4j.Logger;
88 import org.slf4j.LoggerFactory;
90 public class InventoryAndReadAdapter implements IPluginInReadService, IPluginInInventoryService, OpendaylightInventoryListener, OpendaylightFlowStatisticsListener, OpendaylightFlowTableStatisticsListener, OpendaylightPortStatisticsListener {
91 private static final Logger LOG = LoggerFactory.getLogger(InventoryAndReadAdapter.class);
92 private static final short OPENFLOWV10_TABLE_ID = 0;
94 private final InventoryNotificationProvider inventoryNotificationProvider = new InventoryNotificationProvider();
95 private final Map<PathArgument,List<PathArgument>> nodeToNodeConnectorsMap = new ConcurrentHashMap<>();
96 private List<IPluginOutInventoryService> inventoryPublisher = new CopyOnWriteArrayList<>();
97 private List<IPluginOutReadService> statisticsPublisher = new CopyOnWriteArrayList<>();
99 private OpendaylightFlowTableStatisticsService flowTableStatisticsService;
100 private OpendaylightPortStatisticsService nodeConnectorStatisticsService;
101 private OpendaylightFlowStatisticsService flowStatisticsService;
102 private FlowTopologyDiscoveryService topologyDiscovery;
103 private DataProviderService dataProviderService;
104 private DataBrokerService dataService;
106 public DataBrokerService getDataService() {
110 public void setDataService(final DataBrokerService dataService) {
111 this.dataService = dataService;
114 public DataProviderService getDataProviderService() {
115 return dataProviderService;
118 public void setDataProviderService(final DataProviderService dataProviderService) {
119 this.dataProviderService = dataProviderService;
122 public OpendaylightFlowStatisticsService getFlowStatisticsService() {
123 return flowStatisticsService;
126 public void setFlowStatisticsService(final OpendaylightFlowStatisticsService flowStatisticsService) {
127 this.flowStatisticsService = flowStatisticsService;
130 public OpendaylightPortStatisticsService getNodeConnectorStatisticsService() {
131 return nodeConnectorStatisticsService;
134 public void setNodeConnectorStatisticsService(final OpendaylightPortStatisticsService nodeConnectorStatisticsService) {
135 this.nodeConnectorStatisticsService = nodeConnectorStatisticsService;
138 public OpendaylightFlowTableStatisticsService getFlowTableStatisticsService() {
139 return flowTableStatisticsService;
142 public void setFlowTableStatisticsService(final OpendaylightFlowTableStatisticsService flowTableStatisticsService) {
143 this.flowTableStatisticsService = flowTableStatisticsService;
146 public FlowTopologyDiscoveryService getTopologyDiscovery() {
147 return topologyDiscovery;
150 public void setTopologyDiscovery(final FlowTopologyDiscoveryService topologyDiscovery) {
151 this.topologyDiscovery = topologyDiscovery;
154 public List<IPluginOutReadService> getStatisticsPublisher() {
155 return statisticsPublisher;
158 public void setStatisticsPublisher(final List<IPluginOutReadService> statisticsPublisher) {
159 this.statisticsPublisher = statisticsPublisher;
162 public List<IPluginOutInventoryService> getInventoryPublisher() {
163 return inventoryPublisher;
166 public void setInventoryPublisher(final List<IPluginOutInventoryService> inventoryPublisher) {
167 this.inventoryPublisher = inventoryPublisher;
170 public void startAdapter() {
171 inventoryNotificationProvider.setDataProviderService(getDataProviderService());
172 inventoryNotificationProvider.setInventoryPublisher(getInventoryPublisher());
173 // inventoryNotificationProvider.start();
176 public boolean setInventoryPublisher(final IPluginOutInventoryService listener) {
177 return getInventoryPublisher().add(listener);
180 public boolean unsetInventoryPublisher(final IPluginOutInventoryService listener) {
181 return getInventoryPublisher().remove(listener);
184 public boolean setReadPublisher(final IPluginOutReadService listener) {
185 return getStatisticsPublisher().add(listener);
188 public Boolean unsetReadPublisher(final IPluginOutReadService listener) {
189 if (listener != null) {
190 return getStatisticsPublisher().remove(listener);
195 protected DataModificationTransaction startChange() {
196 return getDataProviderService().beginTransaction();
200 public long getTransmitRate(final NodeConnector connector) {
201 final FlowCapableNodeConnector nodeConnector = this.readOperFlowCapableNodeConnector(NodeMapping.toNodeConnectorRef(connector));
202 return nodeConnector.getCurrentSpeed().longValue();
205 private FlowCapableNode readOperFlowCapableNode(final NodeRef ref) {
206 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node =
207 (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node)getDataService().readOperationalData(ref.getValue());
212 return node.getAugmentation(FlowCapableNode.class);
215 private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node readConfigNode(final Node node) {
216 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
217 InstanceIdentifier.builder(Nodes.class)
218 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(node))
221 return (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node) startChange().readConfigurationData(nodeRef);
224 private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector readConfigNodeConnector(final NodeConnector connector) {
225 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector> nodeConnectorRef =
226 InstanceIdentifier.builder(Nodes.class)
227 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(connector.getNode()))
228 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector.class, InventoryMapping.toNodeConnectorKey(connector))
231 return((org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector) startChange().readConfigurationData(nodeConnectorRef));
235 * Read a table of a node from configuration data store.
237 * @param node Node id
239 * @return Table contents, or null if not present
241 private Table readConfigTable(final Node node, final short id) {
242 final InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class)
243 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(node))
244 .augmentation(FlowCapableNode.class)
245 .child(Table.class, new TableKey(id))
248 return (Table) startChange().readConfigurationData(tableRef);
252 public List<FlowOnNode> readAllFlow(final Node node, final boolean cached) {
253 final ArrayList<FlowOnNode> output = new ArrayList<>();
254 final Table table = readConfigTable(node, OPENFLOWV10_TABLE_ID);
256 final List<Flow> flows = table.getFlow();
257 LOG.trace("Number of flows installed in table 0 of node {} : {}", node, flows.size());
259 for (final Flow flow : flows) {
260 final FlowStatisticsData statsFromDataStore = flow.getAugmentation(FlowStatisticsData.class);
261 if (statsFromDataStore != null) {
262 final FlowOnNode it = new FlowOnNode(ToSalConversionsUtils.toFlow(flow, node));
263 output.add(addFlowStats(it, statsFromDataStore.getFlowStatistics()));
268 // TODO (main): Shall we send request to the switch? It will make async request to the switch.
269 // Once the plugin receives a response, it will let the adaptor know through onFlowStatisticsUpdate()
270 // If we assume that md-sal statistics manager will always be running, then it is not required
271 // But if not, then sending request will collect the latest data for adaptor at least.
272 getFlowStatisticsService().getAllFlowsStatisticsFromAllFlowTables(
273 new GetAllFlowsStatisticsFromAllFlowTablesInputBuilder().setNode(NodeMapping.toNodeRef(node)).build());
278 public List<NodeConnectorStatistics> readAllNodeConnector(final Node node, final boolean cached) {
279 final ArrayList<NodeConnectorStatistics> ret = new ArrayList<>();
281 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node dsNode = readConfigNode(node);
282 if (dsNode != null) {
283 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector dsNodeConnector : dsNode.getNodeConnector()) {
284 final FlowCapableNodeConnectorStatistics stats = (dsNodeConnector.getAugmentation(FlowCapableNodeConnectorStatisticsData.class));
287 ret.add(toNodeConnectorStatistics(stats.getFlowCapableNodeConnectorStatistics(), dsNode.getId(), dsNodeConnector.getId()));
288 } catch (ConstructionException e) {
289 LOG.warn("Failed to instantiate node connector statistics for node {} connector {}, ignoring it",
290 dsNode.getId(), dsNodeConnector.getId(), e);
296 //TODO: Refer TODO (main)
297 getNodeConnectorStatisticsService().getAllNodeConnectorsStatistics(
298 new GetAllNodeConnectorsStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(node)).build());
303 public List<NodeTableStatistics> readAllNodeTable(final Node node, final boolean cached) {
304 final NodeRef nodeRef = NodeMapping.toNodeRef(node);
306 final ArrayList<NodeTableStatistics> ret = new ArrayList<>();
307 final FlowCapableNode dsFlowCapableNode = this.readOperFlowCapableNode(nodeRef);
308 if (dsFlowCapableNode != null) {
309 for (final Table table : dsFlowCapableNode.getTable()) {
310 final FlowTableStatisticsData tableStats = table.getAugmentation(FlowTableStatisticsData.class);
311 if (tableStats != null) {
313 ret.add(toNodeTableStatistics(tableStats.getFlowTableStatistics(), table.getId(), node));
314 } catch (ConstructionException e) {
315 LOG.warn("Failed to instantiate table statistics for node {} table {}, ignoring it", node, table.getId(), e);
321 //TODO: Refer TODO (main)
322 getFlowTableStatisticsService().getFlowTablesStatistics(new GetFlowTablesStatisticsInputBuilder().setNode(nodeRef).build());
327 public NodeDescription readDescription(final Node node, final boolean cached) {
328 return this.toNodeDescription(NodeMapping.toNodeRef(node));
332 public FlowOnNode readFlow(final Node node, final org.opendaylight.controller.sal.flowprogrammer.Flow targetFlow, final boolean cached) {
333 FlowOnNode ret = null;
334 final Table table = readConfigTable(node, OPENFLOWV10_TABLE_ID);
336 final List<Flow> flows = table.getFlow();
337 InventoryAndReadAdapter.LOG.trace("Number of flows installed in table 0 of node {} : {}", node, flows.size());
339 for (final Flow mdsalFlow : flows) {
340 if(FromSalConversionsUtils.flowEquals(mdsalFlow, MDFlowMapping.toMDSalflow(targetFlow))) {
341 final FlowStatisticsData statsFromDataStore = mdsalFlow.getAugmentation(FlowStatisticsData.class);
342 if (statsFromDataStore != null) {
343 InventoryAndReadAdapter.LOG.debug("Found matching flow in the data store flow table ");
344 ret = addFlowStats(new FlowOnNode(targetFlow), statsFromDataStore.getFlowStatistics());
352 //TODO: Refer TODO (main)
353 final GetFlowStatisticsFromFlowTableInputBuilder input = new GetFlowStatisticsFromFlowTableInputBuilder().setNode(NodeMapping.toNodeRef(node));
354 input.fieldsFrom(MDFlowMapping.toMDSalflow(targetFlow));
355 getFlowStatisticsService().getFlowStatisticsFromFlowTable(input.build());
360 public NodeConnectorStatistics readNodeConnector(final NodeConnector connector, final boolean cached) {
361 final NodeConnectorId ncId = InventoryMapping.toNodeConnectorKey(connector).getId();
363 NodeConnectorStatistics ret = null;
364 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nodeConnectorFromDS = readConfigNodeConnector(connector);
365 if (nodeConnectorFromDS != null) {
366 final FlowCapableNodeConnectorStatistics stats = nodeConnectorFromDS.getAugmentation(FlowCapableNodeConnectorStatisticsData.class);
369 ret = toNodeConnectorStatistics(stats.getFlowCapableNodeConnectorStatistics(),
370 InventoryMapping.toNodeKey(connector.getNode()).getId(), ncId);
371 } catch (ConstructionException e) {
372 LOG.warn("Failed to instantiate node connector statistics for connector {}, ignoring it",
378 getNodeConnectorStatisticsService().getNodeConnectorStatistics(
379 new GetNodeConnectorStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(connector.getNode())).setNodeConnectorId(ncId).build());
384 public NodeTableStatistics readNodeTable(final NodeTable nodeTable, final boolean cached) {
385 NodeTableStatistics nodeStats = null;
386 final Table table = readConfigTable(nodeTable.getNode(), (short) nodeTable.getID());
388 final FlowTableStatisticsData tableStats = table.getAugmentation(FlowTableStatisticsData.class);
389 if (tableStats != null) {
391 nodeStats = toNodeTableStatistics(tableStats.getFlowTableStatistics(), table.getId(), nodeTable.getNode());
392 } catch (ConstructionException e) {
393 LOG.warn("Failed to instantiate table statistics for node {} table {}, ignoring it",
394 nodeTable.getNode(), table.getId(), e);
399 //TODO: Refer TODO (main)
400 getFlowTableStatisticsService().getFlowTablesStatistics(
401 new GetFlowTablesStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(nodeTable.getNode())).build());
406 public void onNodeConnectorRemoved(final NodeConnectorRemoved update) {
411 public void onNodeRemoved(final NodeRemoved notification) {
412 this.removeNodeConnectors(notification.getNodeRef().getValue());
414 final Node aDNode = NodeMapping.toADNode(notification.getNodeRef());
415 this.publishNodeUpdate(aDNode, UpdateType.REMOVED, Collections.<Property>emptySet());
416 } catch (ConstructionException e) {
417 LOG.warn("Failed to construct node for {}, not propagating update", notification.getNodeRef(), e);
422 public void onNodeConnectorUpdated(final NodeConnectorUpdated update) {
423 final NodeConnectorRef ref = update.getNodeConnectorRef();
424 final UpdateType updateType;
425 if (!this.isKnownNodeConnector(ref.getValue())) {
426 this.recordNodeConnector(ref.getValue());
427 updateType = UpdateType.ADDED;
429 updateType = UpdateType.CHANGED;
433 final NodeConnector nodeConnector;
434 nodeConnector = NodeMapping.toADNodeConnector(ref);
435 this.publishNodeConnectorUpdate(nodeConnector, updateType, NodeMapping.toADNodeConnectorProperties(update));
436 } catch (ConstructionException e) {
437 LOG.warn("Failed to construct node connector for {}, not reporting the update", ref, e);
442 public void onNodeUpdated(final NodeUpdated notification) {
443 final NodeRef ref = notification.getNodeRef();
445 final UpdateType updateType;
446 if (dataService.readOperationalData(ref.getValue()) == null) {
447 updateType = UpdateType.ADDED;
449 updateType = UpdateType.CHANGED;
454 aDNode = NodeMapping.toADNode(ref);
455 } catch (ConstructionException e) {
456 LOG.warn("Failed to construct node for {}, not reporting the update", ref, e);
460 this.publishNodeUpdate(aDNode, updateType, NodeMapping.toADNodeProperties(notification));
461 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
462 final NodeDescription description = this.toNodeDescription(ref);
463 if (description != null) {
464 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
465 InstanceIdentifier.builder(Nodes.class)
466 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
469 statsPublisher.descriptionStatisticsUpdated(NodeMapping.toADNode(nodeRef), description);
470 } catch (ConstructionException e) {
471 LOG.warn("Failed to construct node for {}, not reporting the update to publisher {}", nodeRef, statsPublisher, e);
478 public ConcurrentMap<Node,Map<String,Property>> getNodeProps() {
479 final ConcurrentHashMap<Node,Map<String,Property>> props = new ConcurrentHashMap<>();
480 final Nodes nodes = this.readOperAllMDNodes();
481 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node : nodes.getNode()) {
482 final FlowCapableNode fcn = node.getAugmentation(FlowCapableNode.class);
484 final ConcurrentHashMap<String,Property> perNodePropMap = new ConcurrentHashMap<String, Property>();
485 final HashSet<Property> perNodeProps = NodeMapping.toADNodeProperties(fcn, node.getId());
486 if (perNodeProps != null) {
487 for (final Property perNodeProp : perNodeProps) {
488 perNodePropMap.put(perNodeProp.getName(), perNodeProp);
493 final Node adNode = NodeMapping.toADNode(node.getId());
494 props.put(adNode, perNodePropMap);
495 } catch (ConstructionException e) {
496 LOG.warn("Failed to construct node for {}, skipping it", node, e);
503 private Nodes readOperAllMDNodes() {
504 final TypeSafeDataReader reader = TypeSafeDataReader.forReader(getDataService());
505 return reader.readOperationalData(InstanceIdentifier.builder(Nodes.class).build());
509 public ConcurrentMap<NodeConnector,Map<String,Property>> getNodeConnectorProps(final Boolean refresh) {
510 final ConcurrentHashMap<NodeConnector,Map<String,Property>> props = new ConcurrentHashMap<>();
511 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node : this.readOperAllMDNodes().getNode()) {
512 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : node.getNodeConnector()) {
513 final FlowCapableNodeConnector fcnc = nc.getAugmentation(FlowCapableNodeConnector.class);
515 final ConcurrentHashMap<String,Property> ncpsm = new ConcurrentHashMap<>();
516 final HashSet<Property> ncps = NodeMapping.toADNodeConnectorProperties(fcnc);
518 for (final Property p : ncps) {
519 ncpsm.put(p.getName(), p);
524 props.put(NodeMapping.toADNodeConnector(nc.getId(), node.getId()), ncpsm);
525 } catch (ConstructionException e) {
526 LOG.warn("Failed to instantiate node {} connector {}, not reporting it", node.getId(), nc.getId(), e);
534 private FlowCapableNodeConnector readOperFlowCapableNodeConnector(final NodeConnectorRef ref) {
535 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc =
536 (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector)
537 getDataService().readOperationalData(ref.getValue());
538 return nc.getAugmentation(FlowCapableNodeConnector.class);
541 private static NodeConnectorStatistics toNodeConnectorStatistics(final org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.NodeConnectorStatistics nodeConnectorStatistics, final NodeId nodeId, final NodeConnectorId nodeConnectorId) throws ConstructionException {
542 final NodeConnectorStatistics it = new NodeConnectorStatistics();
544 final Packets packets = nodeConnectorStatistics.getPackets();
545 it.setReceivePacketCount(packets.getReceived().longValue());
546 it.setTransmitPacketCount(packets.getTransmitted().longValue());
548 final Bytes bytes = nodeConnectorStatistics.getBytes();
549 it.setReceiveByteCount(bytes.getReceived().longValue());
550 it.setTransmitByteCount(bytes.getTransmitted().longValue());
552 it.setReceiveDropCount(nodeConnectorStatistics.getReceiveDrops().longValue());
553 it.setTransmitDropCount(nodeConnectorStatistics.getTransmitDrops().longValue());
554 it.setReceiveErrorCount(nodeConnectorStatistics.getReceiveErrors().longValue());
555 it.setTransmitErrorCount(nodeConnectorStatistics.getTransmitErrors().longValue());
556 it.setReceiveFrameErrorCount(nodeConnectorStatistics.getReceiveFrameError().longValue());
557 it.setReceiveOverRunErrorCount(nodeConnectorStatistics.getReceiveOverRunError().longValue());
558 it.setReceiveCRCErrorCount(nodeConnectorStatistics.getReceiveCrcError().longValue());
559 it.setCollisionCount(nodeConnectorStatistics.getCollisionCount().longValue());
561 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector> nodeConnectorRef =
562 InstanceIdentifier.builder(Nodes.class)
563 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(nodeId))
564 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector.class, new NodeConnectorKey(nodeConnectorId))
566 it.setNodeConnector(NodeMapping.toADNodeConnector(new NodeConnectorRef(nodeConnectorRef)));
570 private static NodeTableStatistics toNodeTableStatistics(final FlowTableStatistics tableStats, final Short tableId, final Node node) throws ConstructionException {
571 final NodeTableStatistics it = new NodeTableStatistics();
572 it.setActiveCount(tableStats.getActiveFlows().getValue().intValue());
573 it.setLookupCount(tableStats.getPacketsLookedUp().getValue().longValue());
574 it.setMatchedCount(tableStats.getPacketsMatched().getValue().longValue());
575 it.setName(tableId.toString());
576 it.setNodeTable(new NodeTable(NodeTableIDType.OPENFLOW, tableId.byteValue(), node));
580 private NodeDescription toNodeDescription(final NodeRef nodeRef) {
581 final FlowCapableNode capableNode = this.readOperFlowCapableNode(nodeRef);
582 if (capableNode == null) {
586 final NodeDescription it = new NodeDescription();
587 it.setManufacturer(capableNode.getManufacturer());
588 it.setSerialNumber(capableNode.getSerialNumber());
589 it.setSoftware(capableNode.getSoftware());
590 it.setDescription(capableNode.getDescription());
594 public Edge toADEdge(final Link link) throws ConstructionException {
595 NodeConnectorRef _source = link.getSource();
596 NodeConnector _aDNodeConnector = NodeMapping.toADNodeConnector(_source);
597 NodeConnectorRef _destination = link.getDestination();
598 NodeConnector _aDNodeConnector_1 = NodeMapping.toADNodeConnector(_destination);
599 Edge _edge = new Edge(_aDNodeConnector, _aDNodeConnector_1);
604 * OpendaylightFlowStatisticsListener interface implementation
607 public void onAggregateFlowStatisticsUpdate(final AggregateFlowStatisticsUpdate notification) {
608 // Ignoring this notification as there does not seem to be a way to bubble this up to AD-SAL
612 public void onFlowsStatisticsUpdate(final FlowsStatisticsUpdate notification) {
613 final ArrayList<FlowOnNode> adsalFlowsStatistics = new ArrayList<>();
614 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
615 InstanceIdentifier.builder(Nodes.class)
616 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
621 aDNode = NodeMapping.toADNode(nodeRef);
622 } catch (ConstructionException e) {
623 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
627 for (final FlowAndStatisticsMapList flowStats : notification.getFlowAndStatisticsMapList()) {
628 if (flowStats.getTableId() == 0) {
629 adsalFlowsStatistics.add(InventoryAndReadAdapter.toFlowOnNode(flowStats, aDNode));
632 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
633 statsPublisher.nodeFlowStatisticsUpdated(aDNode, adsalFlowsStatistics);
638 * OpendaylightFlowTableStatisticsListener interface implementation
641 public void onFlowTableStatisticsUpdate(final FlowTableStatisticsUpdate notification) {
642 ArrayList<NodeTableStatistics> adsalFlowTableStatistics = new ArrayList<>();
643 for (final FlowTableAndStatisticsMap stats : notification.getFlowTableAndStatisticsMap()) {
644 if (stats.getTableId().getValue() == 0) {
645 final NodeTableStatistics it = new NodeTableStatistics();
646 it.setActiveCount(stats.getActiveFlows().getValue().intValue());
647 it.setLookupCount(stats.getPacketsLookedUp().getValue().longValue());
648 it.setMatchedCount(stats.getPacketsMatched().getValue().longValue());
649 adsalFlowTableStatistics.add(it);
653 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
654 InstanceIdentifier.builder(Nodes.class)
655 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
660 aDNode = NodeMapping.toADNode(nodeRef);
661 } catch (ConstructionException e) {
662 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
666 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
667 statsPublisher.nodeTableStatisticsUpdated(aDNode, adsalFlowTableStatistics);
672 * OpendaylightPortStatisticsUpdate interface implementation
675 public void onNodeConnectorStatisticsUpdate(final NodeConnectorStatisticsUpdate notification) {
676 final ArrayList<NodeConnectorStatistics> adsalPortStatistics = new ArrayList<NodeConnectorStatistics>();
677 for (final NodeConnectorStatisticsAndPortNumberMap nodeConnectorStatistics : notification.getNodeConnectorStatisticsAndPortNumberMap()) {
679 adsalPortStatistics.add(toNodeConnectorStatistics(
680 nodeConnectorStatistics, notification.getId(), nodeConnectorStatistics.getNodeConnectorId()));
681 } catch (ConstructionException e) {
682 LOG.warn("Failed to create statistics for node {} connector {}, not updating them",
683 notification.getId(), nodeConnectorStatistics.getNodeConnectorId(), e);
687 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
688 InstanceIdentifier.builder(Nodes.class)
689 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
694 aDNode = NodeMapping.toADNode(nodeRef);
695 } catch (ConstructionException e) {
696 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
700 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
701 statsPublisher.nodeConnectorStatisticsUpdated(aDNode, adsalPortStatistics);
705 private static FlowOnNode toFlowOnNode(final FlowAndStatisticsMapList flowAndStatsMap, final Node node) {
706 final FlowOnNode it = new FlowOnNode(ToSalConversionsUtils.toFlow(flowAndStatsMap, node));
707 return addFlowStats(it, flowAndStatsMap);
710 private static FlowOnNode addFlowStats(final FlowOnNode node, final GenericStatistics stats) {
711 node.setByteCount(stats.getByteCount().getValue().longValue());
712 node.setPacketCount(stats.getPacketCount().getValue().longValue());
713 node.setDurationSeconds(stats.getDuration().getSecond().getValue().intValue());
714 node.setDurationNanoseconds(stats.getDuration().getNanosecond().getValue().intValue());
719 public Set<Node> getConfiguredNotConnectedNodes() {
720 return Collections.emptySet();
723 private void publishNodeUpdate(final Node node, final UpdateType updateType, final Set<Property> properties) {
724 for (final IPluginOutInventoryService publisher : getInventoryPublisher()) {
725 publisher.updateNode(node, updateType, properties);
729 private void publishNodeConnectorUpdate(final NodeConnector nodeConnector, final UpdateType updateType, final Set<Property> properties) {
730 for (final IPluginOutInventoryService publisher : getInventoryPublisher()) {
731 publisher.updateNodeConnector(nodeConnector, updateType, properties);
735 private boolean isKnownNodeConnector(final InstanceIdentifier<? extends Object> nodeConnectorIdentifier) {
736 final List<PathArgument> path = nodeConnectorIdentifier.getPath();
737 if (path.size() >= 3) {
738 final PathArgument nodePath = path.get(1);
739 final PathArgument nodeConnectorPath = path.get(2);
740 final List<PathArgument> nodeConnectors = nodeToNodeConnectorsMap.get(nodePath);
741 if (nodeConnectors != null) {
742 return nodeConnectors.contains(nodeConnectorPath);
748 private boolean recordNodeConnector(final InstanceIdentifier<? extends Object> nodeConnectorIdentifier) {
749 final List<PathArgument> path = nodeConnectorIdentifier.getPath();
750 if (path.size() < 3) {
754 final PathArgument nodePath = path.get(1);
755 final PathArgument nodeConnectorPath = path.get(2);
757 synchronized (this) {
758 List<PathArgument> nodeConnectors = this.nodeToNodeConnectorsMap.get(nodePath);
759 if (nodeConnectors == null) {
760 nodeConnectors = new ArrayList<>();
761 this.nodeToNodeConnectorsMap.put(nodePath, nodeConnectors);
764 return nodeConnectors.add(nodeConnectorPath);
768 private List<PathArgument> removeNodeConnectors(final InstanceIdentifier<? extends Object> nodeIdentifier) {
769 return this.nodeToNodeConnectorsMap.remove(nodeIdentifier.getPath().get(1));