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
9 package org.opendaylight.controller.md.statistics.manager.impl;
11 import java.util.ArrayList;
12 import java.util.Collections;
13 import java.util.List;
15 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
16 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
17 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
18 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
19 import org.opendaylight.controller.md.statistics.manager.StatPermCollector.StatCapabTypes;
20 import org.opendaylight.controller.md.statistics.manager.StatRpcMsgManager.TransactionCacheContainer;
21 import org.opendaylight.controller.md.statistics.manager.StatisticsManager;
22 import org.opendaylight.controller.md.statistics.manager.StatisticsManager.StatDataStoreOperation;
23 import org.opendaylight.controller.md.statistics.manager.StatisticsManager.StatDataStoreOperation.StatsManagerOperationType;
24 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
25 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
26 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterBuilder;
28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterKey;
29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev131103.TransactionAware;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev131103.TransactionId;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.MeterConfigStatsUpdated;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.MeterFeaturesUpdated;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.MeterStatisticsUpdated;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterConfigStats;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterConfigStatsBuilder;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterFeatures;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterFeaturesBuilder;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatistics;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatisticsBuilder;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.OpendaylightMeterStatisticsListener;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.MeterFeatures;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.MeterFeaturesBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.meter.MeterConfigStatsBuilder;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.meter.MeterStatistics;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.meter.MeterStatisticsBuilder;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.config.stats.reply.MeterConfigStats;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats;
52 import org.opendaylight.yangtools.yang.binding.DataObject;
53 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
54 import org.slf4j.Logger;
55 import org.slf4j.LoggerFactory;
57 import com.google.common.base.Optional;
58 import com.google.common.base.Preconditions;
62 * org.opendaylight.controller.md.statistics.manager.impl
64 * StatListenCommitMeter
65 * Class is a NotifyListener for MeterStatistics and DataChangeListener for Config/DataStore for Meter node.
66 * All expected (registered) MeterStatistics will be builded and commit to Operational/DataStore.
67 * DataChangeEven should call create/delete Meter in Operational/DS
70 public class StatListenCommitMeter extends StatAbstractListenCommit<Meter, OpendaylightMeterStatisticsListener>
71 implements OpendaylightMeterStatisticsListener {
73 private static final Logger LOG = LoggerFactory.getLogger(StatListenCommitMeter.class);
75 public StatListenCommitMeter(final StatisticsManager manager, final DataBroker db,
76 final NotificationProviderService nps) {
77 super(manager, db, nps, Meter.class);
81 protected InstanceIdentifier<Meter> getWildCardedRegistrationPath() {
82 return InstanceIdentifier.create(Nodes.class).child(Node.class)
83 .augmentation(FlowCapableNode.class).child(Meter.class);
87 protected OpendaylightMeterStatisticsListener getStatNotificationListener() {
92 public void onMeterConfigStatsUpdated(final MeterConfigStatsUpdated notification) {
93 final TransactionId transId = notification.getTransactionId();
94 final NodeId nodeId = notification.getId();
95 if ( ! isExpectedStatistics(transId, nodeId)) {
96 LOG.debug("STAT-MANAGER - MeterConfigStatsUpdated: unregistred notification detect TransactionId {}", transId);
99 manager.getRpcMsgManager().addNotification(notification, nodeId);
100 if (notification.isMoreReplies()) {
104 /* Don't block RPC Notification thread */
105 manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
107 public void applyOperation(final ReadWriteTransaction tx) {
109 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
110 .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
112 /* Validate exist FlowCapableNode */
113 final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
114 Optional<FlowCapableNode> fNode = Optional.absent();
116 fNode = tx.read(LogicalDatastoreType.OPERATIONAL,fNodeIdent).checkedGet();
118 catch (final ReadFailedException e) {
119 LOG.debug("Read Operational/DS for FlowCapableNode fail! {}", fNodeIdent, e);
121 if ( ! fNode.isPresent()) {
124 /* Get and Validate TransactionCacheContainer */
125 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
126 if ( ! isTransactionCacheContainerValid(txContainer)) {
129 /* Prepare List actual Meters and not updated Meters will be removed */
130 final List<Meter> existMeters = fNode.get().getMeter() != null
131 ? fNode.get().getMeter() : Collections.<Meter> emptyList();
132 final List<MeterKey> existMeterKeys = new ArrayList<>();
133 for (final Meter meter : existMeters) {
134 existMeterKeys.add(meter.getKey());
136 /* MeterConfig processing */
137 comitConfMeterStats(txContainer, tx, fNodeIdent, existMeterKeys);
138 /* Delete all not presented Meter Nodes */
139 deleteAllNotPresentedNodes(fNodeIdent, tx, Collections.unmodifiableList(existMeterKeys));
140 /* Notification for continue collecting statistics */
141 notifyToCollectNextStatistics(nodeIdent, transId);
147 public void onMeterFeaturesUpdated(final MeterFeaturesUpdated notification) {
148 Preconditions.checkNotNull(notification);
149 final TransactionId transId = notification.getTransactionId();
150 final NodeId nodeId = notification.getId();
151 if ( ! isExpectedStatistics(transId, nodeId)) {
152 LOG.debug("STAT-MANAGER - MeterFeaturesUpdated: unregistred notification detect TransactionId {}", transId);
155 manager.getRpcMsgManager().addNotification(notification, nodeId);
156 if (notification.isMoreReplies()) {
160 /* Don't block RPC Notification thread */
161 manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
163 public void applyOperation(final ReadWriteTransaction tx) {
164 /* Get and Validate TransactionCacheContainer */
165 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
166 if ( ! isTransactionCacheContainerValid(txContainer)) {
170 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
171 .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
173 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
174 for (final TransactionAware notif : cacheNotifs) {
175 if ( ! (notif instanceof MeterFeaturesUpdated)) {
178 final MeterFeatures stats = new MeterFeaturesBuilder((MeterFeaturesUpdated)notif).build();
179 final InstanceIdentifier<NodeMeterFeatures> nodeMeterFeatureIdent =
180 nodeIdent.augmentation(NodeMeterFeatures.class);
181 final InstanceIdentifier<MeterFeatures> meterFeatureIdent = nodeMeterFeatureIdent
182 .child(MeterFeatures.class);
183 Optional<Node> node = Optional.absent();
185 node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
187 catch (final ReadFailedException e) {
188 LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
190 if (node.isPresent()) {
191 tx.merge(LogicalDatastoreType.OPERATIONAL, nodeMeterFeatureIdent, new NodeMeterFeaturesBuilder().build(), true);
192 tx.put(LogicalDatastoreType.OPERATIONAL, meterFeatureIdent, stats);
193 manager.registerAdditionalNodeFeature(nodeIdent, StatCapabTypes.METER_STATS);
201 public void onMeterStatisticsUpdated(final MeterStatisticsUpdated notification) {
202 Preconditions.checkNotNull(notification);
203 final TransactionId transId = notification.getTransactionId();
204 final NodeId nodeId = notification.getId();
205 if ( ! isExpectedStatistics(transId, nodeId)) {
206 LOG.debug("STAT-MANAGER - MeterStatisticsUpdated: unregistred notification detect TransactionId {}", transId);
209 manager.getRpcMsgManager().addNotification(notification, nodeId);
210 if (notification.isMoreReplies()) {
214 /* Don't block RPC Notification thread */
215 manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
217 public void applyOperation(final ReadWriteTransaction tx) {
219 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
220 .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
221 /* Node exist check */
222 Optional<Node> node = Optional.absent();
224 node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
226 catch (final ReadFailedException e) {
227 LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
229 if ( ! node.isPresent()) {
233 /* Get and Validate TransactionCacheContainer */
234 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
235 if ( ! isTransactionCacheContainerValid(txContainer)) {
238 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
240 Optional<Meter> notifMeter = Optional.absent();
241 final Optional<? extends DataObject> inputObj = txContainer.get().getConfInput();
242 if (inputObj.isPresent() && inputObj.get() instanceof Meter) {
243 notifMeter = Optional.<Meter> of((Meter)inputObj.get());
245 for (final TransactionAware notif : cacheNotifs) {
246 if ( ! (notif instanceof MeterStatisticsUpdated)) {
249 statMeterCommit(((MeterStatisticsUpdated) notif).getMeterStats(), nodeIdent, tx);
251 if ( ! notifMeter.isPresent()) {
252 notifyToCollectNextStatistics(nodeIdent, transId);
258 private void statMeterCommit(final List<MeterStats> meterStats,
259 final InstanceIdentifier<Node> nodeIdent, final ReadWriteTransaction tx) {
261 Preconditions.checkNotNull(meterStats);
262 Preconditions.checkNotNull(nodeIdent);
263 Preconditions.checkNotNull(tx);
265 final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
267 for (final MeterStats mStat : meterStats) {
268 final MeterStatistics stats = new MeterStatisticsBuilder(mStat).build();
270 final InstanceIdentifier<Meter> meterIdent = fNodeIdent.child(Meter.class, new MeterKey(mStat.getMeterId()));
271 final InstanceIdentifier<NodeMeterStatistics> nodeMeterStatIdent = meterIdent
272 .augmentation(NodeMeterStatistics.class);
273 final InstanceIdentifier<MeterStatistics> msIdent = nodeMeterStatIdent.child(MeterStatistics.class);
274 /* Meter Statistics commit */
275 Optional<Meter> meter = Optional.absent();
277 meter = tx.read(LogicalDatastoreType.OPERATIONAL, meterIdent).checkedGet();
279 catch (final ReadFailedException e) {
280 LOG.debug("Read Operational/DS for FlowCapableNode fail! {}", fNodeIdent, e);
282 if (meter.isPresent()) {
283 tx.merge(LogicalDatastoreType.OPERATIONAL, nodeMeterStatIdent, new NodeMeterStatisticsBuilder().build(), true);
284 tx.put(LogicalDatastoreType.OPERATIONAL, msIdent, stats);
289 private void comitConfMeterStats(final Optional<TransactionCacheContainer<?>> txContainer, final ReadWriteTransaction tx,
290 final InstanceIdentifier<FlowCapableNode> fNodeIdent, final List<MeterKey> existMeterKeys) {
292 Preconditions.checkNotNull(existMeterKeys);
293 Preconditions.checkNotNull(txContainer);
294 Preconditions.checkNotNull(fNodeIdent);
295 Preconditions.checkNotNull(tx);
297 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
298 for (final TransactionAware notif : cacheNotifs) {
299 if ( ! (notif instanceof MeterConfigStatsUpdated)) {
302 final List<MeterConfigStats> meterStats = ((MeterConfigStatsUpdated) notif).getMeterConfigStats();
303 if (meterStats == null) {
306 for (final MeterConfigStats meterStat : meterStats) {
307 if (meterStat.getMeterId() != null) {
308 final MeterBuilder meterBuilder = new MeterBuilder(meterStat);
309 final MeterKey meterKey = new MeterKey(meterStat.getMeterId());
310 final InstanceIdentifier<Meter> meterRef = fNodeIdent.child(Meter.class, meterKey);
312 final NodeMeterConfigStatsBuilder meterConfig = new NodeMeterConfigStatsBuilder();
313 meterConfig.setMeterConfigStats(new MeterConfigStatsBuilder(meterStat).build());
314 //Update augmented data
315 meterBuilder.addAugmentation(NodeMeterConfigStats.class, meterConfig.build());
316 existMeterKeys.remove(meterKey);
317 tx.put(LogicalDatastoreType.OPERATIONAL, meterRef, meterBuilder.build());
323 private void deleteAllNotPresentedNodes(final InstanceIdentifier<FlowCapableNode> fNodeIdent,
324 final ReadWriteTransaction tx, final List<MeterKey> deviceMeterKeys) {
326 Preconditions.checkNotNull(fNodeIdent);
327 Preconditions.checkNotNull(tx);
329 if (deviceMeterKeys == null) {
333 for (final MeterKey key : deviceMeterKeys) {
334 final InstanceIdentifier<Meter> delMeterIdent = fNodeIdent.child(Meter.class, key);
335 LOG.trace("Meter {} has to removed.", key);
336 Optional<Meter> delMeter = Optional.absent();
338 delMeter = tx.read(LogicalDatastoreType.OPERATIONAL, delMeterIdent).checkedGet();
340 catch (final ReadFailedException e) {
341 // NOOP - probably another transaction delete that node
343 if (delMeter.isPresent()) {
344 tx.delete(LogicalDatastoreType.OPERATIONAL, delMeterIdent);