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.Iterator;
14 import java.util.List;
17 import java.util.concurrent.ConcurrentHashMap;
18 import java.util.concurrent.ConcurrentMap;
19 import java.util.concurrent.CopyOnWriteArrayList;
21 import org.opendaylight.controller.md.sal.binding.util.TypeSafeDataReader;
22 import org.opendaylight.controller.sal.binding.api.data.DataBrokerService;
23 import org.opendaylight.controller.sal.binding.api.data.DataModificationTransaction;
24 import org.opendaylight.controller.sal.binding.api.data.DataProviderService;
25 import org.opendaylight.controller.sal.core.ConstructionException;
26 import org.opendaylight.controller.sal.core.Edge;
27 import org.opendaylight.controller.sal.core.Node;
28 import org.opendaylight.controller.sal.core.NodeConnector;
29 import org.opendaylight.controller.sal.core.NodeTable;
30 import org.opendaylight.controller.sal.core.NodeTable.NodeTableIDType;
31 import org.opendaylight.controller.sal.core.Property;
32 import org.opendaylight.controller.sal.core.UpdateType;
33 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
34 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService;
35 import org.opendaylight.controller.sal.reader.FlowOnNode;
36 import org.opendaylight.controller.sal.reader.IPluginInReadService;
37 import org.opendaylight.controller.sal.reader.IPluginOutReadService;
38 import org.opendaylight.controller.sal.reader.NodeConnectorStatistics;
39 import org.opendaylight.controller.sal.reader.NodeDescription;
40 import org.opendaylight.controller.sal.reader.NodeTableStatistics;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.Table;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.TableKey;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.tables.table.Flow;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.AggregateFlowStatisticsUpdate;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowStatisticsData;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.statistics.rev130819.FlowsStatisticsUpdate;
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.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 import com.google.common.collect.Iterables;
91 public class InventoryAndReadAdapter implements IPluginInReadService, IPluginInInventoryService, OpendaylightFlowStatisticsListener, OpendaylightFlowTableStatisticsListener, OpendaylightPortStatisticsListener {
92 private static final Logger LOG = LoggerFactory.getLogger(InventoryAndReadAdapter.class);
93 private static final short OPENFLOWV10_TABLE_ID = 0;
95 private final InventoryNotificationProvider inventoryNotificationProvider = new InventoryNotificationProvider();
96 private final Map<PathArgument,List<PathArgument>> nodeToNodeConnectorsMap = new ConcurrentHashMap<>();
97 private List<IPluginOutInventoryService> inventoryPublisher = new CopyOnWriteArrayList<>();
98 private List<IPluginOutReadService> statisticsPublisher = new CopyOnWriteArrayList<>();
100 private OpendaylightFlowTableStatisticsService flowTableStatisticsService;
101 private OpendaylightPortStatisticsService nodeConnectorStatisticsService;
102 private OpendaylightFlowStatisticsService flowStatisticsService;
103 private FlowTopologyDiscoveryService topologyDiscovery;
104 private DataProviderService dataProviderService;
105 private DataBrokerService dataService;
107 public DataBrokerService getDataService() {
111 public void setDataService(final DataBrokerService dataService) {
112 this.dataService = dataService;
115 public DataProviderService getDataProviderService() {
116 return dataProviderService;
119 public void setDataProviderService(final DataProviderService dataProviderService) {
120 this.dataProviderService = dataProviderService;
123 public OpendaylightFlowStatisticsService getFlowStatisticsService() {
124 return flowStatisticsService;
127 public void setFlowStatisticsService(final OpendaylightFlowStatisticsService flowStatisticsService) {
128 this.flowStatisticsService = flowStatisticsService;
131 public OpendaylightPortStatisticsService getNodeConnectorStatisticsService() {
132 return nodeConnectorStatisticsService;
135 public void setNodeConnectorStatisticsService(final OpendaylightPortStatisticsService nodeConnectorStatisticsService) {
136 this.nodeConnectorStatisticsService = nodeConnectorStatisticsService;
139 public OpendaylightFlowTableStatisticsService getFlowTableStatisticsService() {
140 return flowTableStatisticsService;
143 public void setFlowTableStatisticsService(final OpendaylightFlowTableStatisticsService flowTableStatisticsService) {
144 this.flowTableStatisticsService = flowTableStatisticsService;
147 public FlowTopologyDiscoveryService getTopologyDiscovery() {
148 return topologyDiscovery;
151 public void setTopologyDiscovery(final FlowTopologyDiscoveryService topologyDiscovery) {
152 this.topologyDiscovery = topologyDiscovery;
155 public List<IPluginOutReadService> getStatisticsPublisher() {
156 return statisticsPublisher;
159 public void setStatisticsPublisher(final List<IPluginOutReadService> statisticsPublisher) {
160 this.statisticsPublisher = statisticsPublisher;
163 public List<IPluginOutInventoryService> getInventoryPublisher() {
164 return inventoryPublisher;
167 public void setInventoryPublisher(final List<IPluginOutInventoryService> inventoryPublisher) {
168 this.inventoryPublisher = inventoryPublisher;
171 public void startAdapter() {
172 inventoryNotificationProvider.setDataProviderService(getDataProviderService());
173 inventoryNotificationProvider.setInventoryPublisher(getInventoryPublisher());
174 // inventoryNotificationProvider.start();
177 public boolean setInventoryPublisher(final IPluginOutInventoryService listener) {
178 return getInventoryPublisher().add(listener);
181 public boolean unsetInventoryPublisher(final IPluginOutInventoryService listener) {
182 return getInventoryPublisher().remove(listener);
185 public boolean setReadPublisher(final IPluginOutReadService listener) {
186 return getStatisticsPublisher().add(listener);
189 public Boolean unsetReadPublisher(final IPluginOutReadService listener) {
190 if (listener != null) {
191 return getStatisticsPublisher().remove(listener);
196 protected DataModificationTransaction startChange() {
197 return getDataProviderService().beginTransaction();
201 public long getTransmitRate(final NodeConnector connector) {
202 final FlowCapableNodeConnector nodeConnector = this.readOperFlowCapableNodeConnector(NodeMapping.toNodeConnectorRef(connector));
203 return nodeConnector.getCurrentSpeed().longValue();
206 private FlowCapableNode readOperFlowCapableNode(final NodeRef ref) {
207 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node =
208 (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node)getDataService().readOperationalData(ref.getValue());
213 return node.getAugmentation(FlowCapableNode.class);
216 private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node readConfigNode(final Node node) {
217 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
218 InstanceIdentifier.builder(Nodes.class)
219 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(node))
222 return (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node) startChange().readConfigurationData(nodeRef);
225 private org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector readConfigNodeConnector(final NodeConnector connector) {
226 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector> nodeConnectorRef =
227 InstanceIdentifier.builder(Nodes.class)
228 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, InventoryMapping.toNodeKey(connector.getNode()))
229 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector.class, InventoryMapping.toNodeConnectorKey(connector))
232 return((org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector) startChange().readConfigurationData(nodeConnectorRef));
236 * Read a table of a node from configuration data store.
238 * @param node Node id
240 * @return Table contents, or null if not present
242 private Table readOperationalTable(final Node node, final short id) {
243 final InstanceIdentifier<Table> tableRef = InstanceIdentifier.builder(Nodes.class)
244 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, NodeMapping.toNodeKey(node))
245 .augmentation(FlowCapableNode.class)
246 .child(Table.class, new TableKey(id))
249 return (Table) startChange().readOperationalData(tableRef);
253 public List<FlowOnNode> readAllFlow(final Node node, final boolean cached) {
254 final ArrayList<FlowOnNode> output = new ArrayList<>();
255 final Table table = readOperationalTable(node, OPENFLOWV10_TABLE_ID);
257 final List<Flow> flows = table.getFlow();
258 LOG.trace("Number of flows installed in table 0 of node {} : {}", node, flows.size());
260 for (final Flow flow : flows) {
261 final FlowStatisticsData statsFromDataStore = flow.getAugmentation(FlowStatisticsData.class);
262 if (statsFromDataStore != null) {
263 final FlowOnNode it = new FlowOnNode(ToSalConversionsUtils.toFlow(flow, node));
264 output.add(addFlowStats(it, statsFromDataStore.getFlowStatistics()));
273 public List<NodeConnectorStatistics> readAllNodeConnector(final Node node, final boolean cached) {
274 final ArrayList<NodeConnectorStatistics> ret = new ArrayList<>();
276 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node dsNode = readConfigNode(node);
277 if (dsNode != null) {
278 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector dsNodeConnector : dsNode.getNodeConnector()) {
279 final FlowCapableNodeConnectorStatistics stats = (dsNodeConnector.getAugmentation(FlowCapableNodeConnectorStatisticsData.class));
282 ret.add(toNodeConnectorStatistics(stats.getFlowCapableNodeConnectorStatistics(), dsNode.getId(), dsNodeConnector.getId()));
283 } catch (ConstructionException e) {
284 LOG.warn("Failed to instantiate node connector statistics for node {} connector {}, ignoring it",
285 dsNode.getId(), dsNodeConnector.getId(), e);
291 //TODO: Refer TODO (main)
292 getNodeConnectorStatisticsService().getAllNodeConnectorsStatistics(
293 new GetAllNodeConnectorsStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(node)).build());
298 public List<NodeTableStatistics> readAllNodeTable(final Node node, final boolean cached) {
299 final NodeRef nodeRef = NodeMapping.toNodeRef(node);
301 final ArrayList<NodeTableStatistics> ret = new ArrayList<>();
302 final FlowCapableNode dsFlowCapableNode = this.readOperFlowCapableNode(nodeRef);
303 if (dsFlowCapableNode != null) {
304 for (final Table table : dsFlowCapableNode.getTable()) {
305 final FlowTableStatisticsData tableStats = table.getAugmentation(FlowTableStatisticsData.class);
306 if (tableStats != null) {
308 ret.add(toNodeTableStatistics(tableStats.getFlowTableStatistics(), table.getId(), node));
309 } catch (ConstructionException e) {
310 LOG.warn("Failed to instantiate table statistics for node {} table {}, ignoring it", node, table.getId(), e);
316 //TODO: Refer TODO (main)
317 getFlowTableStatisticsService().getFlowTablesStatistics(new GetFlowTablesStatisticsInputBuilder().setNode(nodeRef).build());
322 public NodeDescription readDescription(final Node node, final boolean cached) {
323 return this.toNodeDescription(NodeMapping.toNodeRef(node));
327 public FlowOnNode readFlow(final Node node, final org.opendaylight.controller.sal.flowprogrammer.Flow targetFlow, final boolean cached) {
328 FlowOnNode ret = null;
329 final Table table = readOperationalTable(node, OPENFLOWV10_TABLE_ID);
331 final List<Flow> flows = table.getFlow();
332 InventoryAndReadAdapter.LOG.trace("Number of flows installed in table 0 of node {} : {}", node, flows.size());
334 for (final Flow mdsalFlow : flows) {
335 if(FromSalConversionsUtils.flowEquals(mdsalFlow, MDFlowMapping.toMDSalflow(targetFlow))) {
336 final FlowStatisticsData statsFromDataStore = mdsalFlow.getAugmentation(FlowStatisticsData.class);
337 if (statsFromDataStore != null) {
338 InventoryAndReadAdapter.LOG.debug("Found matching flow in the data store flow table ");
339 ret = addFlowStats(new FlowOnNode(targetFlow), statsFromDataStore.getFlowStatistics());
347 //TODO: Refer TODO (main)
348 final GetFlowStatisticsFromFlowTableInputBuilder input = new GetFlowStatisticsFromFlowTableInputBuilder().setNode(NodeMapping.toNodeRef(node));
349 input.fieldsFrom(MDFlowMapping.toMDSalflow(targetFlow));
350 getFlowStatisticsService().getFlowStatisticsFromFlowTable(input.build());
355 public NodeConnectorStatistics readNodeConnector(final NodeConnector connector, final boolean cached) {
356 final NodeConnectorId ncId = InventoryMapping.toNodeConnectorKey(connector).getId();
358 NodeConnectorStatistics ret = null;
359 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nodeConnectorFromDS = readConfigNodeConnector(connector);
360 if (nodeConnectorFromDS != null) {
361 final FlowCapableNodeConnectorStatistics stats = nodeConnectorFromDS.getAugmentation(FlowCapableNodeConnectorStatisticsData.class);
364 ret = toNodeConnectorStatistics(stats.getFlowCapableNodeConnectorStatistics(),
365 InventoryMapping.toNodeKey(connector.getNode()).getId(), ncId);
366 } catch (ConstructionException e) {
367 LOG.warn("Failed to instantiate node connector statistics for connector {}, ignoring it",
373 getNodeConnectorStatisticsService().getNodeConnectorStatistics(
374 new GetNodeConnectorStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(connector.getNode())).setNodeConnectorId(ncId).build());
379 public NodeTableStatistics readNodeTable(final NodeTable nodeTable, final boolean cached) {
380 NodeTableStatistics nodeStats = null;
381 final Table table = readOperationalTable(nodeTable.getNode(), (short) nodeTable.getID());
383 final FlowTableStatisticsData tableStats = table.getAugmentation(FlowTableStatisticsData.class);
384 if (tableStats != null) {
386 nodeStats = toNodeTableStatistics(tableStats.getFlowTableStatistics(), table.getId(), nodeTable.getNode());
387 } catch (ConstructionException e) {
388 LOG.warn("Failed to instantiate table statistics for node {} table {}, ignoring it",
389 nodeTable.getNode(), table.getId(), e);
394 //TODO: Refer TODO (main)
395 getFlowTableStatisticsService().getFlowTablesStatistics(
396 new GetFlowTablesStatisticsInputBuilder().setNode(NodeMapping.toNodeRef(nodeTable.getNode())).build());
400 public void onNodeConnectorRemovedInternal(final NodeConnectorRemoved update) {
404 public void onNodeRemovedInternal(final NodeRemoved notification) {
405 this.removeNodeConnectors(notification.getNodeRef().getValue());
407 final Node aDNode = NodeMapping.toADNode(notification.getNodeRef());
408 this.publishNodeUpdate(aDNode, UpdateType.REMOVED, Collections.<Property>emptySet());
409 } catch (ConstructionException e) {
410 LOG.warn("Failed to construct node for {}, not propagating update", notification.getNodeRef(), e);
414 public void onNodeConnectorUpdatedInternal(final NodeConnectorUpdated update) {
415 final NodeConnectorRef ref = update.getNodeConnectorRef();
416 final UpdateType updateType;
417 if (!this.isKnownNodeConnector(ref.getValue())) {
418 this.recordNodeConnector(ref.getValue());
419 updateType = UpdateType.ADDED;
421 updateType = UpdateType.CHANGED;
425 final NodeConnector nodeConnector;
426 nodeConnector = NodeMapping.toADNodeConnector(ref);
427 this.publishNodeConnectorUpdate(nodeConnector, updateType, NodeMapping.toADNodeConnectorProperties(update));
428 } catch (ConstructionException e) {
429 LOG.warn("Failed to construct node connector for {}, not reporting the update", ref, e);
433 public void onNodeUpdatedInternal(final NodeUpdated notification) {
434 final NodeRef ref = notification.getNodeRef();
436 final UpdateType updateType;
437 if (dataService.readOperationalData(ref.getValue()) == null) {
438 updateType = UpdateType.ADDED;
440 updateType = UpdateType.CHANGED;
445 aDNode = NodeMapping.toADNode(ref);
446 } catch (ConstructionException e) {
447 LOG.warn("Failed to construct node for {}, not reporting the update", ref, e);
451 this.publishNodeUpdate(aDNode, updateType, NodeMapping.toADNodeProperties(notification));
452 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
453 final NodeDescription description = this.toNodeDescription(ref);
454 if (description != null) {
455 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
456 InstanceIdentifier.builder(Nodes.class)
457 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
460 statsPublisher.descriptionStatisticsUpdated(NodeMapping.toADNode(nodeRef), description);
461 } catch (ConstructionException e) {
462 LOG.warn("Failed to construct node for {}, not reporting the update to publisher {}", nodeRef, statsPublisher, e);
469 public ConcurrentMap<Node,Map<String,Property>> getNodeProps() {
470 final ConcurrentHashMap<Node,Map<String,Property>> props = new ConcurrentHashMap<>();
471 final Nodes nodes = this.readOperAllMDNodes();
472 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node : nodes.getNode()) {
473 final FlowCapableNode fcn = node.getAugmentation(FlowCapableNode.class);
475 final ConcurrentHashMap<String,Property> perNodePropMap = new ConcurrentHashMap<String, Property>();
476 final HashSet<Property> perNodeProps = NodeMapping.toADNodeProperties(fcn, node.getId());
477 if (perNodeProps != null) {
478 for (final Property perNodeProp : perNodeProps) {
479 perNodePropMap.put(perNodeProp.getName(), perNodeProp);
484 final Node adNode = NodeMapping.toADNode(node.getId());
485 props.put(adNode, perNodePropMap);
486 } catch (ConstructionException e) {
487 LOG.warn("Failed to construct node for {}, skipping it", node, e);
494 private Nodes readOperAllMDNodes() {
495 final TypeSafeDataReader reader = TypeSafeDataReader.forReader(getDataService());
496 return reader.readOperationalData(InstanceIdentifier.builder(Nodes.class).build());
500 public ConcurrentMap<NodeConnector,Map<String,Property>> getNodeConnectorProps(final Boolean refresh) {
501 final ConcurrentHashMap<NodeConnector,Map<String,Property>> props = new ConcurrentHashMap<>();
502 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node node : this.readOperAllMDNodes().getNode()) {
503 for (final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc : node.getNodeConnector()) {
504 final FlowCapableNodeConnector fcnc = nc.getAugmentation(FlowCapableNodeConnector.class);
506 final ConcurrentHashMap<String,Property> ncpsm = new ConcurrentHashMap<>();
507 final HashSet<Property> ncps = NodeMapping.toADNodeConnectorProperties(fcnc);
509 for (final Property p : ncps) {
510 ncpsm.put(p.getName(), p);
515 props.put(NodeMapping.toADNodeConnector(nc.getId(), node.getId()), ncpsm);
516 } catch (ConstructionException e) {
517 LOG.warn("Failed to instantiate node {} connector {}, not reporting it", node.getId(), nc.getId(), e);
525 private FlowCapableNodeConnector readOperFlowCapableNodeConnector(final NodeConnectorRef ref) {
526 final org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector nc =
527 (org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector)
528 getDataService().readOperationalData(ref.getValue());
529 return nc.getAugmentation(FlowCapableNodeConnector.class);
532 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 {
533 final NodeConnectorStatistics it = new NodeConnectorStatistics();
535 final Packets packets = nodeConnectorStatistics.getPackets();
536 it.setReceivePacketCount(packets.getReceived().longValue());
537 it.setTransmitPacketCount(packets.getTransmitted().longValue());
539 final Bytes bytes = nodeConnectorStatistics.getBytes();
540 it.setReceiveByteCount(bytes.getReceived().longValue());
541 it.setTransmitByteCount(bytes.getTransmitted().longValue());
543 it.setReceiveDropCount(nodeConnectorStatistics.getReceiveDrops().longValue());
544 it.setTransmitDropCount(nodeConnectorStatistics.getTransmitDrops().longValue());
545 it.setReceiveErrorCount(nodeConnectorStatistics.getReceiveErrors().longValue());
546 it.setTransmitErrorCount(nodeConnectorStatistics.getTransmitErrors().longValue());
547 it.setReceiveFrameErrorCount(nodeConnectorStatistics.getReceiveFrameError().longValue());
548 it.setReceiveOverRunErrorCount(nodeConnectorStatistics.getReceiveOverRunError().longValue());
549 it.setReceiveCRCErrorCount(nodeConnectorStatistics.getReceiveCrcError().longValue());
550 it.setCollisionCount(nodeConnectorStatistics.getCollisionCount().longValue());
552 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector> nodeConnectorRef =
553 InstanceIdentifier.builder(Nodes.class)
554 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(nodeId))
555 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector.class, new NodeConnectorKey(nodeConnectorId))
557 it.setNodeConnector(NodeMapping.toADNodeConnector(new NodeConnectorRef(nodeConnectorRef)));
561 private static NodeTableStatistics toNodeTableStatistics(final FlowTableStatistics tableStats, final Short tableId, final Node node) throws ConstructionException {
562 final NodeTableStatistics it = new NodeTableStatistics();
563 it.setActiveCount(tableStats.getActiveFlows().getValue().intValue());
564 it.setLookupCount(tableStats.getPacketsLookedUp().getValue().longValue());
565 it.setMatchedCount(tableStats.getPacketsMatched().getValue().longValue());
566 it.setName(tableId.toString());
567 it.setNodeTable(new NodeTable(NodeTableIDType.OPENFLOW, tableId.byteValue(), node));
571 private NodeDescription toNodeDescription(final NodeRef nodeRef) {
572 final FlowCapableNode capableNode = this.readOperFlowCapableNode(nodeRef);
573 if (capableNode == null) {
577 final NodeDescription it = new NodeDescription();
578 it.setManufacturer(capableNode.getManufacturer());
579 it.setSerialNumber(capableNode.getSerialNumber());
580 it.setSoftware(capableNode.getSoftware());
581 it.setDescription(capableNode.getDescription());
585 public Edge toADEdge(final Link link) throws ConstructionException {
586 NodeConnectorRef _source = link.getSource();
587 NodeConnector _aDNodeConnector = NodeMapping.toADNodeConnector(_source);
588 NodeConnectorRef _destination = link.getDestination();
589 NodeConnector _aDNodeConnector_1 = NodeMapping.toADNodeConnector(_destination);
590 Edge _edge = new Edge(_aDNodeConnector, _aDNodeConnector_1);
595 * OpendaylightFlowStatisticsListener interface implementation
598 public void onAggregateFlowStatisticsUpdate(final AggregateFlowStatisticsUpdate notification) {
599 // Ignoring this notification as there does not seem to be a way to bubble this up to AD-SAL
603 public void onFlowsStatisticsUpdate(final FlowsStatisticsUpdate notification) {
604 final ArrayList<FlowOnNode> adsalFlowsStatistics = new ArrayList<>();
605 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
606 InstanceIdentifier.builder(Nodes.class)
607 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
612 aDNode = NodeMapping.toADNode(nodeRef);
613 } catch (ConstructionException e) {
614 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
618 for (final FlowAndStatisticsMapList flowStats : notification.getFlowAndStatisticsMapList()) {
619 if (flowStats.getTableId() == 0) {
620 adsalFlowsStatistics.add(InventoryAndReadAdapter.toFlowOnNode(flowStats, aDNode));
623 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
624 statsPublisher.nodeFlowStatisticsUpdated(aDNode, adsalFlowsStatistics);
629 * OpendaylightFlowTableStatisticsListener interface implementation
632 public void onFlowTableStatisticsUpdate(final FlowTableStatisticsUpdate notification) {
633 ArrayList<NodeTableStatistics> adsalFlowTableStatistics = new ArrayList<>();
634 for (final FlowTableAndStatisticsMap stats : notification.getFlowTableAndStatisticsMap()) {
635 if (stats.getTableId().getValue() == 0) {
636 final NodeTableStatistics it = new NodeTableStatistics();
637 it.setActiveCount(stats.getActiveFlows().getValue().intValue());
638 it.setLookupCount(stats.getPacketsLookedUp().getValue().longValue());
639 it.setMatchedCount(stats.getPacketsMatched().getValue().longValue());
640 adsalFlowTableStatistics.add(it);
644 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
645 InstanceIdentifier.builder(Nodes.class)
646 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
651 aDNode = NodeMapping.toADNode(nodeRef);
652 } catch (ConstructionException e) {
653 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
657 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
658 statsPublisher.nodeTableStatisticsUpdated(aDNode, adsalFlowTableStatistics);
663 * OpendaylightPortStatisticsUpdate interface implementation
666 public void onNodeConnectorStatisticsUpdate(final NodeConnectorStatisticsUpdate notification) {
667 final ArrayList<NodeConnectorStatistics> adsalPortStatistics = new ArrayList<NodeConnectorStatistics>();
668 for (final NodeConnectorStatisticsAndPortNumberMap nodeConnectorStatistics : notification.getNodeConnectorStatisticsAndPortNumberMap()) {
670 adsalPortStatistics.add(toNodeConnectorStatistics(
671 nodeConnectorStatistics, notification.getId(), nodeConnectorStatistics.getNodeConnectorId()));
672 } catch (ConstructionException e) {
673 LOG.warn("Failed to create statistics for node {} connector {}, not updating them",
674 notification.getId(), nodeConnectorStatistics.getNodeConnectorId(), e);
678 final InstanceIdentifier<org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node> nodeRef =
679 InstanceIdentifier.builder(Nodes.class)
680 .child(org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node.class, new NodeKey(notification.getId()))
685 aDNode = NodeMapping.toADNode(nodeRef);
686 } catch (ConstructionException e) {
687 LOG.warn("Failed to construct node for {}, ignoring it", notification.getId(), e);
691 for (final IPluginOutReadService statsPublisher : getStatisticsPublisher()) {
692 statsPublisher.nodeConnectorStatisticsUpdated(aDNode, adsalPortStatistics);
696 private static FlowOnNode toFlowOnNode(final FlowAndStatisticsMapList flowAndStatsMap, final Node node) {
697 final FlowOnNode it = new FlowOnNode(ToSalConversionsUtils.toFlow(flowAndStatsMap, node));
698 return addFlowStats(it, flowAndStatsMap);
701 private static FlowOnNode addFlowStats(final FlowOnNode node, final GenericStatistics stats) {
702 node.setByteCount(stats.getByteCount().getValue().longValue());
703 node.setPacketCount(stats.getPacketCount().getValue().longValue());
704 node.setDurationSeconds(stats.getDuration().getSecond().getValue().intValue());
705 node.setDurationNanoseconds(stats.getDuration().getNanosecond().getValue().intValue());
710 public Set<Node> getConfiguredNotConnectedNodes() {
711 return Collections.emptySet();
714 private void publishNodeUpdate(final Node node, final UpdateType updateType, final Set<Property> properties) {
715 for (final IPluginOutInventoryService publisher : getInventoryPublisher()) {
716 publisher.updateNode(node, updateType, properties);
720 private void publishNodeConnectorUpdate(final NodeConnector nodeConnector, final UpdateType updateType, final Set<Property> properties) {
721 for (final IPluginOutInventoryService publisher : getInventoryPublisher()) {
722 publisher.updateNodeConnector(nodeConnector, updateType, properties);
726 private boolean isKnownNodeConnector(final InstanceIdentifier<? extends Object> nodeConnectorIdentifier) {
727 final Iterator<PathArgument> it = nodeConnectorIdentifier.getPathArguments().iterator();
737 final PathArgument nodePath = it.next();
742 final PathArgument nodeConnectorPath = it.next();
744 final List<PathArgument> nodeConnectors = nodeToNodeConnectorsMap.get(nodePath);
745 return nodeConnectors == null ? false :
746 nodeConnectors.contains(nodeConnectorPath);
749 private boolean recordNodeConnector(final InstanceIdentifier<? extends Object> nodeConnectorIdentifier) {
750 final Iterator<PathArgument> it = nodeConnectorIdentifier.getPathArguments().iterator();
760 final PathArgument nodePath = it.next();
765 final PathArgument nodeConnectorPath = it.next();
767 synchronized (this) {
768 List<PathArgument> nodeConnectors = this.nodeToNodeConnectorsMap.get(nodePath);
769 if (nodeConnectors == null) {
770 nodeConnectors = new ArrayList<>();
771 this.nodeToNodeConnectorsMap.put(nodePath, nodeConnectors);
774 return nodeConnectors.add(nodeConnectorPath);
778 private List<PathArgument> removeNodeConnectors(final InstanceIdentifier<? extends Object> nodeIdentifier) {
779 return this.nodeToNodeConnectorsMap.remove(Iterables.get(nodeIdentifier.getPathArguments(), 1));