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.Property;
30 import org.opendaylight.controller.sal.core.UpdateType;
31 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
32 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService;
33 import org.opendaylight.controller.sal.reader.FlowOnNode;
34 import org.opendaylight.controller.sal.reader.IPluginInReadService;
35 import org.opendaylight.controller.sal.reader.IPluginOutReadService;
36 import org.opendaylight.controller.sal.reader.NodeConnectorStatistics;
37 import org.opendaylight.controller.sal.reader.NodeDescription;
38 import org.opendaylight.controller.sal.reader.NodeTableStatistics;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdate;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdate;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetAllFlowsStatisticsFromAllFlowTablesInputBuilder;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.GetFlowStatisticsFromFlowTableInputBuilder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsListener;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.OpendaylightFlowStatisticsService;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.flow.and.statistics.map.list.FlowAndStatisticsMapList;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsData;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.FlowTableStatisticsUpdate;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.GetFlowTablesStatisticsInputBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsListener;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.OpendaylightFlowTableStatisticsService;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.and.statistics.map.FlowTableAndStatisticsMap;
58 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.table.statistics.rev131215.flow.table.statistics.FlowTableStatistics;
59 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.FlowTopologyDiscoveryService;
60 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.topology.discovery.rev130819.Link;
61 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorId;
62 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRef;
63 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved;
64 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
65 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
66 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
67 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved;
68 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
69 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
70 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.OpendaylightInventoryListener;
71 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
72 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
73 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.GenericStatistics;
74 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Bytes;
75 import org.opendaylight.yang.gen.v1.urn.opendaylight.model.statistics.types.rev130925.node.connector.statistics.Packets;
76 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatistics;
77 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.FlowCapableNodeConnectorStatisticsData;
78 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetAllNodeConnectorsStatisticsInputBuilder;
79 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.GetNodeConnectorStatisticsInputBuilder;
80 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.NodeConnectorStatisticsUpdate;
81 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsListener;
82 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.OpendaylightPortStatisticsService;
83 import org.opendaylight.yang.gen.v1.urn.opendaylight.port.statistics.rev131214.node.connector.statistics.and.port.number.map.NodeConnectorStatisticsAndPortNumberMap;
84 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
85 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier.PathArgument;
86 import org.slf4j.Logger;
87 import org.slf4j.LoggerFactory;
89 public class InventoryAndReadAdapter implements IPluginInReadService, IPluginInInventoryService, OpendaylightInventoryListener, OpendaylightFlowStatisticsListener, OpendaylightFlowTableStatisticsListener, OpendaylightPortStatisticsListener {
90 private static final Logger LOG = LoggerFactory.getLogger(InventoryAndReadAdapter.class);
91 private static final short OPENFLOWV10_TABLE_ID = 0;
93 private final InventoryNotificationProvider inventoryNotificationProvider = new InventoryNotificationProvider();
94 private final Map<PathArgument,List<PathArgument>> nodeToNodeConnectorsMap = new ConcurrentHashMap<>();
95 private List<IPluginOutInventoryService> inventoryPublisher = new CopyOnWriteArrayList<>();
96 private List<IPluginOutReadService> statisticsPublisher = new CopyOnWriteArrayList<>();
98 private OpendaylightFlowTableStatisticsService flowTableStatisticsService;
99 private OpendaylightPortStatisticsService nodeConnectorStatisticsService;
100 private OpendaylightFlowStatisticsService flowStatisticsService;
101 private FlowTopologyDiscoveryService topologyDiscovery;
102 private DataProviderService dataProviderService;
103 private DataBrokerService dataService;
105 public DataBrokerService getDataService() {
109 public void setDataService(final DataBrokerService dataService) {
110 this.dataService = dataService;
113 public DataProviderService getDataProviderService() {
114 return dataProviderService;
117 public void setDataProviderService(final DataProviderService dataProviderService) {
118 this.dataProviderService = dataProviderService;
121 public OpendaylightFlowStatisticsService getFlowStatisticsService() {
122 return flowStatisticsService;
125 public void setFlowStatisticsService(final OpendaylightFlowStatisticsService flowStatisticsService) {
126 this.flowStatisticsService = flowStatisticsService;
129 public OpendaylightPortStatisticsService getNodeConnectorStatisticsService() {
130 return nodeConnectorStatisticsService;
133 public void setNodeConnectorStatisticsService(final OpendaylightPortStatisticsService nodeConnectorStatisticsService) {
134 this.nodeConnectorStatisticsService = nodeConnectorStatisticsService;
137 public OpendaylightFlowTableStatisticsService getFlowTableStatisticsService() {
138 return flowTableStatisticsService;
141 public void setFlowTableStatisticsService(final OpendaylightFlowTableStatisticsService flowTableStatisticsService) {
142 this.flowTableStatisticsService = flowTableStatisticsService;
145 public FlowTopologyDiscoveryService getTopologyDiscovery() {
146 return topologyDiscovery;
149 public void setTopologyDiscovery(final FlowTopologyDiscoveryService topologyDiscovery) {
150 this.topologyDiscovery = topologyDiscovery;
153 public List<IPluginOutReadService> getStatisticsPublisher() {
154 return statisticsPublisher;
157 public void setStatisticsPublisher(final List<IPluginOutReadService> statisticsPublisher) {
158 this.statisticsPublisher = statisticsPublisher;
161 public List<IPluginOutInventoryService> getInventoryPublisher() {
162 return inventoryPublisher;
165 public void setInventoryPublisher(final List<IPluginOutInventoryService> inventoryPublisher) {
166 this.inventoryPublisher = inventoryPublisher;
169 public void startAdapter() {
170 inventoryNotificationProvider.setDataProviderService(getDataProviderService());
171 inventoryNotificationProvider.setInventoryPublisher(getInventoryPublisher());
172 // inventoryNotificationProvider.start();
175 public boolean setInventoryPublisher(final IPluginOutInventoryService listener) {
176 return getInventoryPublisher().add(listener);
179 public boolean unsetInventoryPublisher(final IPluginOutInventoryService listener) {
180 return getInventoryPublisher().remove(listener);
183 public boolean setReadPublisher(final IPluginOutReadService listener) {
184 return getStatisticsPublisher().add(listener);
187 public Boolean unsetReadPublisher(final IPluginOutReadService listener) {
188 if (listener != null) {
189 return getStatisticsPublisher().remove(listener);
194 protected DataModificationTransaction startChange() {
195 return getDataProviderService().beginTransaction();
199 public long getTransmitRate(final NodeConnector connector) {
200 final FlowCapableNodeConnector nodeConnector = this.readOperFlowCapableNodeConnector(NodeMapping.toNodeConnectorRef(connector));
201 return nodeConnector.getCurrentSpeed().longValue();
204 private FlowCapableNode readOperFlowCapableNode(final NodeRef ref) {
205 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node =
206 (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node)getDataService().readOperationalData(ref.getValue());
211 return node.getAugmentation(FlowCapableNode.class);
214 private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node readConfigNode(final Node node) {
215 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
216 InstanceIdentifier.builder(Nodes.class)
217 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(node))
220 return (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node) startChange().readConfigurationData(nodeRef);
223 private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector readConfigNodeConnector(final NodeConnector connector) {
224 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector> nodeConnectorRef =
225 InstanceIdentifier.builder(Nodes.class)
226 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(connector.getNode()))
227 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector.class, InventoryMapping.toNodeConnectorKey(connector))
230 return((org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector) startChange().readConfigurationData(nodeConnectorRef));
234 * Read a table of a node from configuration data store.
236 * @param node Node id
238 * @return Table contents, or null if not present
240 private Table readConfigTable(final Node node, final short id) {
241 final InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class)
242 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(node))
243 .augmentation(FlowCapableNode.class)
244 .child(Table.class, new TableKey(id))
247 return (Table) startChange().readConfigurationData(tableRef);
251 public List<FlowOnNode> readAllFlow(final Node node, final boolean cached) {
252 final ArrayList<FlowOnNode> output = new ArrayList<>();
253 final Table table = readConfigTable(node, OPENFLOWV10_TABLE_ID);
255 final List<Flow> flows = table.getFlow();
256 LOG.trace("Number of flows installed in table 0 of node {} : {}", node, flows.size());
258 for (final Flow flow : flows) {
259 final FlowStatisticsData statsFromDataStore = flow.getAugmentation(FlowStatisticsData.class);
260 if (statsFromDataStore != null) {
261 final FlowOnNode it = new FlowOnNode(ToSalConversionsUtils.toFlow(flow, node));
262 output.add(addFlowStats(it, statsFromDataStore.getFlowStatistics()));
267 // TODO (main): Shall we send request to the switch? It will make async request to the switch.
268 // Once the plugin receives a response, it will let the adaptor know through onFlowStatisticsUpdate()
269 // If we assume that md-sal statistics manager will always be running, then it is not required
270 // But if not, then sending request will collect the latest data for adaptor at least.
271 getFlowStatisticsService().getAllFlowsStatisticsFromAllFlowTables(
272 new GetAllFlowsStatisticsFromAllFlowTablesInputBuilder().setNode(NodeMapping.toNodeRef(node)).build());
277 public List<NodeConnectorStatistics> readAllNodeConnector(final Node node, final boolean cached) {
278 final ArrayList<NodeConnectorStatistics> ret = new ArrayList<>();
280 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node dsNode = readConfigNode(node);
281 if (dsNode != null) {
282 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector dsNodeConnector : dsNode.getNodeConnector()) {
283 final FlowCapableNodeConnectorStatistics stats = (dsNodeConnector.getAugmentation(FlowCapableNodeConnectorStatisticsData.class));
286 ret.add(toNodeConnectorStatistics(stats.getFlowCapableNodeConnectorStatistics(), dsNode.getId(), dsNodeConnector.getId()));
287 } catch (ConstructionException e) {
288 LOG.warn("Failed to instantiate node connector statistics for node {} connector {}, ignoring it",
289 dsNode.getId(), dsNodeConnector.getId(), e);
295 //TODO: Refer TODO (main)
296 getNodeConnectorStatisticsService().getAllNodeConnectorsStatistics(
297 new GetAllNodeConnectorsStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(node)).build());
302 public List<NodeTableStatistics> readAllNodeTable(final Node node, final boolean cached) {
303 final NodeRef nodeRef = NodeMapping.toNodeRef(node);
305 final ArrayList<NodeTableStatistics> ret = new ArrayList<>();
306 final FlowCapableNode dsFlowCapableNode = this.readOperFlowCapableNode(nodeRef);
307 if (dsFlowCapableNode != null) {
308 for (final Table table : dsFlowCapableNode.getTable()) {
309 final FlowTableStatisticsData tableStats = table.getAugmentation(FlowTableStatisticsData.class);
310 if (tableStats != null) {
312 ret.add(toNodeTableStatistics(tableStats.getFlowTableStatistics(), table.getId(), node));
313 } catch (ConstructionException e) {
314 LOG.warn("Failed to instantiate table statistics for node {} table {}, ignoring it", node, table.getId(), e);
320 //TODO: Refer TODO (main)
321 getFlowTableStatisticsService().getFlowTablesStatistics(new GetFlowTablesStatisticsInputBuilder().setNode(nodeRef).build());
326 public NodeDescription readDescription(final Node node, final boolean cached) {
327 return this.toNodeDescription(NodeMapping.toNodeRef(node));
331 public FlowOnNode readFlow(final Node node, final org.opendaylight.controller.sal.flowprogrammer.Flow targetFlow, final boolean cached) {
332 FlowOnNode ret = null;
333 final Table table = readConfigTable(node, OPENFLOWV10_TABLE_ID);
335 final List<Flow> flows = table.getFlow();
336 InventoryAndReadAdapter.LOG.trace("Number of flows installed in table 0 of node {} : {}", node, flows.size());
338 for (final Flow mdsalFlow : flows) {
339 if(FromSalConversionsUtils.flowEquals(mdsalFlow, MDFlowMapping.toMDSalflow(targetFlow))) {
340 final FlowStatisticsData statsFromDataStore = mdsalFlow.getAugmentation(FlowStatisticsData.class);
341 if (statsFromDataStore != null) {
342 InventoryAndReadAdapter.LOG.debug("Found matching flow in the data store flow table ");
343 ret = addFlowStats(new FlowOnNode(targetFlow), statsFromDataStore.getFlowStatistics());
351 //TODO: Refer TODO (main)
352 final GetFlowStatisticsFromFlowTableInputBuilder input = new GetFlowStatisticsFromFlowTableInputBuilder().setNode(NodeMapping.toNodeRef(node));
353 input.fieldsFrom(MDFlowMapping.toMDSalflow(targetFlow));
354 getFlowStatisticsService().getFlowStatisticsFromFlowTable(input.build());
359 public NodeConnectorStatistics readNodeConnector(final NodeConnector connector, final boolean cached) {
360 final NodeConnectorId ncId = InventoryMapping.toNodeConnectorKey(connector).getId();
362 NodeConnectorStatistics ret = null;
363 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nodeConnectorFromDS = readConfigNodeConnector(connector);
364 if (nodeConnectorFromDS != null) {
365 final FlowCapableNodeConnectorStatistics stats = nodeConnectorFromDS.getAugmentation(FlowCapableNodeConnectorStatisticsData.class);
368 ret = toNodeConnectorStatistics(stats.getFlowCapableNodeConnectorStatistics(),
369 InventoryMapping.toNodeKey(connector.getNode()).getId(), ncId);
370 } catch (ConstructionException e) {
371 LOG.warn("Failed to instantiate node connector statistics for connector {}, ignoring it",
377 getNodeConnectorStatisticsService().getNodeConnectorStatistics(
378 new GetNodeConnectorStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(connector.getNode())).setNodeConnectorId(ncId).build());
383 public NodeTableStatistics readNodeTable(final NodeTable nodeTable, final boolean cached) {
384 NodeTableStatistics nodeStats = null;
385 final Table table = readConfigTable(nodeTable.getNode(), (short) nodeTable.getID());
387 final FlowTableStatisticsData tableStats = table.getAugmentation(FlowTableStatisticsData.class);
388 if (tableStats != null) {
390 nodeStats = toNodeTableStatistics(tableStats.getFlowTableStatistics(), table.getId(), nodeTable.getNode());
391 } catch (ConstructionException e) {
392 LOG.warn("Failed to instantiate table statistics for node {} table {}, ignoring it",
393 nodeTable.getNode(), table.getId(), e);
398 //TODO: Refer TODO (main)
399 getFlowTableStatisticsService().getFlowTablesStatistics(
400 new GetFlowTablesStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(nodeTable.getNode())).build());
405 public void onNodeConnectorRemoved(final NodeConnectorRemoved update) {
410 public void onNodeRemoved(final NodeRemoved notification) {
411 this.removeNodeConnectors(notification.getNodeRef().getValue());
413 final Node aDNode = NodeMapping.toADNode(notification.getNodeRef());
414 this.publishNodeUpdate(aDNode, UpdateType.REMOVED, Collections.<Property>emptySet());
415 } catch (ConstructionException e) {
416 LOG.warn("Failed to construct node for {}, not propagating update", notification.getNodeRef(), e);
421 public void onNodeConnectorUpdated(final NodeConnectorUpdated update) {
422 final NodeConnectorRef ref = update.getNodeConnectorRef();
423 final UpdateType updateType;
424 if (!this.isKnownNodeConnector(ref.getValue())) {
425 this.recordNodeConnector(ref.getValue());
426 updateType = UpdateType.ADDED;
428 updateType = UpdateType.CHANGED;
432 final NodeConnector nodeConnector;
433 nodeConnector = NodeMapping.toADNodeConnector(ref);
434 this.publishNodeConnectorUpdate(nodeConnector, updateType, NodeMapping.toADNodeConnectorProperties(update));
435 } catch (ConstructionException e) {
436 LOG.warn("Failed to construct node connector for {}, not reporting the update", ref, e);
441 public void onNodeUpdated(final NodeUpdated notification) {
442 final NodeRef ref = notification.getNodeRef();
444 final UpdateType updateType;
445 if (dataService.readOperationalData(ref.getValue()) == null) {
446 updateType = UpdateType.ADDED;
448 updateType = UpdateType.CHANGED;
453 aDNode = NodeMapping.toADNode(ref);
454 } catch (ConstructionException e) {
455 LOG.warn("Failed to construct node for {}, not reporting the update", ref, e);
459 this.publishNodeUpdate(aDNode, updateType, NodeMapping.toADNodeProperties(notification));
460 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
461 final NodeDescription description = this.toNodeDescription(ref);
462 if (description != null) {
463 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
464 InstanceIdentifier.builder(Nodes.class)
465 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
468 statsPublisher.descriptionStatisticsUpdated(NodeMapping.toADNode(nodeRef), description);
469 } catch (ConstructionException e) {
470 LOG.warn("Failed to construct node for {}, not reporting the update to publisher {}", nodeRef, statsPublisher, e);
477 public ConcurrentMap<Node,Map<String,Property>> getNodeProps() {
478 final ConcurrentHashMap<Node,Map<String,Property>> props = new ConcurrentHashMap<>();
479 final Nodes nodes = this.readOperAllMDNodes();
480 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node : nodes.getNode()) {
481 final FlowCapableNode fcn = node.getAugmentation(FlowCapableNode.class);
483 final ConcurrentHashMap<String,Property> perNodePropMap = new ConcurrentHashMap<String, Property>();
484 final HashSet<Property> perNodeProps = NodeMapping.toADNodeProperties(fcn, node.getId());
485 if (perNodeProps != null) {
486 for (final Property perNodeProp : perNodeProps) {
487 perNodePropMap.put(perNodeProp.getName(), perNodeProp);
492 final Node adNode = new Node(NodeMapping.MD_SAL_TYPE, NodeMapping.toADNodeId(node.getId()));
493 props.put(adNode, perNodePropMap);
494 } catch (ConstructionException e) {
495 LOG.warn("Failed to construct node for {}, skipping it", node, e);
502 private Nodes readOperAllMDNodes() {
503 final TypeSafeDataReader reader = TypeSafeDataReader.forReader(getDataService());
504 return reader.readOperationalData(InstanceIdentifier.builder(Nodes.class).build());
508 public ConcurrentMap<NodeConnector,Map<String,Property>> getNodeConnectorProps(final Boolean refresh) {
509 final ConcurrentHashMap<NodeConnector,Map<String,Property>> props = new ConcurrentHashMap<>();
510 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node : this.readOperAllMDNodes().getNode()) {
511 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : node.getNodeConnector()) {
512 final FlowCapableNodeConnector fcnc = nc.getAugmentation(FlowCapableNodeConnector.class);
514 final ConcurrentHashMap<String,Property> ncpsm = new ConcurrentHashMap<>();
515 final HashSet<Property> ncps = NodeMapping.toADNodeConnectorProperties(fcnc);
517 for (final Property p : ncps) {
518 ncpsm.put(p.getName(), p);
523 props.put(NodeMapping.toADNodeConnector(nc.getId(), node.getId()), ncpsm);
524 } catch (ConstructionException e) {
525 LOG.warn("Failed to instantiate node {} connector {}, not reporting it", node.getId(), nc.getId(), e);
533 private FlowCapableNodeConnector readOperFlowCapableNodeConnector(final NodeConnectorRef ref) {
534 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc =
535 (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector)
536 getDataService().readOperationalData(ref.getValue());
537 return nc.getAugmentation(FlowCapableNodeConnector.class);
540 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 {
541 final NodeConnectorStatistics it = new NodeConnectorStatistics();
543 final Packets packets = nodeConnectorStatistics.getPackets();
544 it.setReceivePacketCount(packets.getReceived().longValue());
545 it.setTransmitPacketCount(packets.getTransmitted().longValue());
547 final Bytes bytes = nodeConnectorStatistics.getBytes();
548 it.setReceiveByteCount(bytes.getReceived().longValue());
549 it.setTransmitByteCount(bytes.getTransmitted().longValue());
551 it.setReceiveDropCount(nodeConnectorStatistics.getReceiveDrops().longValue());
552 it.setTransmitDropCount(nodeConnectorStatistics.getTransmitDrops().longValue());
553 it.setReceiveErrorCount(nodeConnectorStatistics.getReceiveErrors().longValue());
554 it.setTransmitErrorCount(nodeConnectorStatistics.getTransmitErrors().longValue());
555 it.setReceiveFrameErrorCount(nodeConnectorStatistics.getReceiveFrameError().longValue());
556 it.setReceiveOverRunErrorCount(nodeConnectorStatistics.getReceiveOverRunError().longValue());
557 it.setReceiveCRCErrorCount(nodeConnectorStatistics.getReceiveCrcError().longValue());
558 it.setCollisionCount(nodeConnectorStatistics.getCollisionCount().longValue());
560 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector> nodeConnectorRef =
561 InstanceIdentifier.builder(Nodes.class)
562 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(nodeId))
563 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector.class, new NodeConnectorKey(nodeConnectorId))
565 it.setNodeConnector(NodeMapping.toADNodeConnector(new NodeConnectorRef(nodeConnectorRef)));
569 private static NodeTableStatistics toNodeTableStatistics(final FlowTableStatistics tableStats, final Short tableId, final Node node) throws ConstructionException {
570 final NodeTableStatistics it = new NodeTableStatistics();
571 it.setActiveCount(tableStats.getActiveFlows().getValue().intValue());
572 it.setLookupCount(tableStats.getPacketsLookedUp().getValue().longValue());
573 it.setMatchedCount(tableStats.getPacketsMatched().getValue().longValue());
574 it.setName(tableId.toString());
575 it.setNodeTable(new NodeTable(NodeMapping.MD_SAL_TYPE, tableId, node));
579 private NodeDescription toNodeDescription(final NodeRef nodeRef) {
580 final FlowCapableNode capableNode = this.readOperFlowCapableNode(nodeRef);
581 if (capableNode == null) {
585 final NodeDescription it = new NodeDescription();
586 it.setManufacturer(capableNode.getManufacturer());
587 it.setSerialNumber(capableNode.getSerialNumber());
588 it.setSoftware(capableNode.getSoftware());
589 it.setDescription(capableNode.getDescription());
593 public Edge toADEdge(final Link link) throws ConstructionException {
594 NodeConnectorRef _source = link.getSource();
595 NodeConnector _aDNodeConnector = NodeMapping.toADNodeConnector(_source);
596 NodeConnectorRef _destination = link.getDestination();
597 NodeConnector _aDNodeConnector_1 = NodeMapping.toADNodeConnector(_destination);
598 Edge _edge = new Edge(_aDNodeConnector, _aDNodeConnector_1);
603 * OpendaylightFlowStatisticsListener interface implementation
606 public void onAggregateFlowStatisticsUpdate(final AggregateFlowStatisticsUpdate notification) {
607 // Ignoring this notification as there does not seem to be a way to bubble this up to AD-SAL
611 public void onFlowsStatisticsUpdate(final FlowsStatisticsUpdate notification) {
612 final ArrayList<FlowOnNode> adsalFlowsStatistics = new ArrayList<>();
613 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
614 InstanceIdentifier.builder(Nodes.class)
615 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
620 aDNode = NodeMapping.toADNode(nodeRef);
621 } catch (ConstructionException e) {
622 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
626 for (final FlowAndStatisticsMapList flowStats : notification.getFlowAndStatisticsMapList()) {
627 if (flowStats.getTableId() == 0) {
628 adsalFlowsStatistics.add(InventoryAndReadAdapter.toFlowOnNode(flowStats, aDNode));
631 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
632 statsPublisher.nodeFlowStatisticsUpdated(aDNode, adsalFlowsStatistics);
637 * OpendaylightFlowTableStatisticsListener interface implementation
640 public void onFlowTableStatisticsUpdate(final FlowTableStatisticsUpdate notification) {
641 ArrayList<NodeTableStatistics> adsalFlowTableStatistics = new ArrayList<>();
642 for (final FlowTableAndStatisticsMap stats : notification.getFlowTableAndStatisticsMap()) {
643 if (stats.getTableId().getValue() == 0) {
644 final NodeTableStatistics it = new NodeTableStatistics();
645 it.setActiveCount(stats.getActiveFlows().getValue().intValue());
646 it.setLookupCount(stats.getPacketsLookedUp().getValue().longValue());
647 it.setMatchedCount(stats.getPacketsMatched().getValue().longValue());
648 adsalFlowTableStatistics.add(it);
652 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
653 InstanceIdentifier.builder(Nodes.class)
654 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
659 aDNode = NodeMapping.toADNode(nodeRef);
660 } catch (ConstructionException e) {
661 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
665 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
666 statsPublisher.nodeTableStatisticsUpdated(aDNode, adsalFlowTableStatistics);
671 * OpendaylightPortStatisticsUpdate interface implementation
674 public void onNodeConnectorStatisticsUpdate(final NodeConnectorStatisticsUpdate notification) {
675 final ArrayList<NodeConnectorStatistics> adsalPortStatistics = new ArrayList<NodeConnectorStatistics>();
676 for (final NodeConnectorStatisticsAndPortNumberMap nodeConnectorStatistics : notification.getNodeConnectorStatisticsAndPortNumberMap()) {
678 adsalPortStatistics.add(toNodeConnectorStatistics(
679 nodeConnectorStatistics, notification.getId(), nodeConnectorStatistics.getNodeConnectorId()));
680 } catch (ConstructionException e) {
681 LOG.warn("Failed to create statistics for node {} connector {}, not updating them",
682 notification.getId(), nodeConnectorStatistics.getNodeConnectorId(), e);
686 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
687 InstanceIdentifier.builder(Nodes.class)
688 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
693 aDNode = NodeMapping.toADNode(nodeRef);
694 } catch (ConstructionException e) {
695 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
699 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
700 statsPublisher.nodeConnectorStatisticsUpdated(aDNode, adsalPortStatistics);
704 private static FlowOnNode toFlowOnNode(final FlowAndStatisticsMapList flowAndStatsMap, final Node node) {
705 final FlowOnNode it = new FlowOnNode(ToSalConversionsUtils.toFlow(flowAndStatsMap, node));
706 return addFlowStats(it, flowAndStatsMap);
709 private static FlowOnNode addFlowStats(final FlowOnNode node, final GenericStatistics stats) {
710 node.setByteCount(stats.getByteCount().getValue().longValue());
711 node.setPacketCount(stats.getPacketCount().getValue().longValue());
712 node.setDurationSeconds(stats.getDuration().getSecond().getValue().intValue());
713 node.setDurationNanoseconds(stats.getDuration().getNanosecond().getValue().intValue());
718 public Set<Node> getConfiguredNotConnectedNodes() {
719 return Collections.emptySet();
722 private void publishNodeUpdate(final Node node, final UpdateType updateType, final Set<Property> properties) {
723 for (final IPluginOutInventoryService publisher : getInventoryPublisher()) {
724 publisher.updateNode(node, updateType, properties);
728 private void publishNodeConnectorUpdate(final NodeConnector nodeConnector, final UpdateType updateType, final Set<Property> properties) {
729 for (final IPluginOutInventoryService publisher : getInventoryPublisher()) {
730 publisher.updateNodeConnector(nodeConnector, updateType, properties);
734 private boolean isKnownNodeConnector(final InstanceIdentifier<? extends Object> nodeConnectorIdentifier) {
735 final List<PathArgument> path = nodeConnectorIdentifier.getPath();
736 if (path.size() >= 3) {
737 final PathArgument nodePath = path.get(1);
738 final PathArgument nodeConnectorPath = path.get(2);
739 final List<PathArgument> nodeConnectors = nodeToNodeConnectorsMap.get(nodePath);
740 if (nodeConnectors != null) {
741 return nodeConnectors.contains(nodeConnectorPath);
747 private boolean recordNodeConnector(final InstanceIdentifier<? extends Object> nodeConnectorIdentifier) {
748 final List<PathArgument> path = nodeConnectorIdentifier.getPath();
749 if (path.size() < 3) {
753 final PathArgument nodePath = path.get(1);
754 final PathArgument nodeConnectorPath = path.get(2);
756 synchronized (this) {
757 List<PathArgument> nodeConnectors = this.nodeToNodeConnectorsMap.get(nodePath);
758 if (nodeConnectors == null) {
759 nodeConnectors = new ArrayList<>();
760 this.nodeToNodeConnectorsMap.put(nodePath, nodeConnectors);
763 return nodeConnectors.add(nodeConnectorPath);
767 private List<PathArgument> removeNodeConnectors(final InstanceIdentifier<? extends Object> nodeIdentifier) {
768 return this.nodeToNodeConnectorsMap.remove(nodeIdentifier.getPath().get(1));