Merge "Bug 6110: Fixed bugs in statistics manager due to race condition." into stable...
[openflowplugin.git] / applications / statistics-manager / src / main / java / org / opendaylight / openflowplugin / applications / statistics / manager / impl / StatListenCommitMeter.java
1 /**
2  * Copyright (c) 2014 Cisco Systems, Inc. and others.  All rights reserved.
3  *
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
7  */
8
9 package org.opendaylight.openflowplugin.applications.statistics.manager.impl;
10
11 import com.google.common.base.Optional;
12 import com.google.common.base.Preconditions;
13 import java.util.ArrayList;
14 import java.util.Collection;
15 import java.util.Collections;
16 import java.util.List;
17 import java.util.UUID;
18 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
19 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
20 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
22 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
23 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
24 import org.opendaylight.openflowplugin.applications.statistics.manager.StatNodeRegistration;
25 import org.opendaylight.openflowplugin.applications.statistics.manager.StatPermCollector.StatCapabTypes;
26 import org.opendaylight.openflowplugin.applications.statistics.manager.StatRpcMsgManager.TransactionCacheContainer;
27 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager;
28 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager.StatDataStoreOperation;
29 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager.StatDataStoreOperation.StatsManagerOperationType;
30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.Meter;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterBuilder;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.meters.MeterKey;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.TransactionAware;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.TransactionId;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.MeterConfigStatsUpdated;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.MeterFeaturesUpdated;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.MeterStatisticsUpdated;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterConfigStats;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterConfigStatsBuilder;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterFeatures;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterFeaturesBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatistics;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.NodeMeterStatisticsBuilder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.OpendaylightMeterStatisticsListener;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.MeterFeatures;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.MeterFeaturesBuilder;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.meter.MeterConfigStatsBuilder;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.meter.MeterStatistics;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.statistics.rev131111.nodes.node.meter.MeterStatisticsBuilder;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.config.stats.reply.MeterConfigStats;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.meter.types.rev130918.meter.statistics.reply.MeterStats;
57 import org.opendaylight.yangtools.yang.binding.DataObject;
58 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
59 import org.slf4j.Logger;
60 import org.slf4j.LoggerFactory;
61
62 /**
63  * statistics-manager
64  * org.opendaylight.openflowplugin.applications.statistics.manager.impl
65  *
66  * StatListenCommitMeter
67  * Class is a NotifyListener for MeterStatistics and DataTreeChangeListener for Config/DataStore for Meter node.
68  * All expected (registered) MeterStatistics will be builded and commit to Operational/DataStore.
69  * DataTreeModification should call create/delete Meter in Operational/DS
70  */
71 public class StatListenCommitMeter extends StatAbstractListenCommit<Meter, OpendaylightMeterStatisticsListener>
72                                             implements OpendaylightMeterStatisticsListener {
73
74     private static final Logger LOG = LoggerFactory.getLogger(StatListenCommitMeter.class);
75
76     public StatListenCommitMeter(final StatisticsManager manager, final DataBroker db,
77             final NotificationProviderService nps,
78                                  final StatNodeRegistration nrm) {
79         super(manager, db, nps, Meter.class,nrm);
80     }
81
82     @Override
83     protected InstanceIdentifier<Meter> getWildCardedRegistrationPath() {
84         return InstanceIdentifier.create(Nodes.class).child(Node.class)
85                 .augmentation(FlowCapableNode.class).child(Meter.class);
86     }
87
88     @Override
89     protected void processDataChange(Collection<DataTreeModification<Meter>> changes) {
90         //NO-OP
91     }
92
93     @Override
94     protected OpendaylightMeterStatisticsListener getStatNotificationListener() {
95         return this;
96     }
97
98     @Override
99     public void onMeterConfigStatsUpdated(final MeterConfigStatsUpdated notification) {
100         final TransactionId transId = notification.getTransactionId();
101         final NodeId nodeId = notification.getId();
102         if ( ! isExpectedStatistics(transId, nodeId)) {
103             LOG.debug("STAT-MANAGER - MeterConfigStatsUpdated: unregistred notification detect TransactionId {}", transId);
104             return;
105         }
106         manager.getRpcMsgManager().addNotification(notification, nodeId);
107         if (notification.isMoreReplies()) {
108             return;
109         }
110
111         /* Don't block RPC Notification thread */
112         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
113             @Override
114             public void applyOperation(final ReadWriteTransaction tx) {
115
116                 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
117                         .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
118
119                 /* Validate exist FlowCapableNode */
120                 final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
121                 Optional<FlowCapableNode> fNode = Optional.absent();
122                 try {
123                     fNode = tx.read(LogicalDatastoreType.OPERATIONAL,fNodeIdent).checkedGet();
124                 }
125                 catch (final ReadFailedException e) {
126                     LOG.debug("Read Operational/DS for FlowCapableNode fail! {}", fNodeIdent, e);
127                 }
128                 if ( ! fNode.isPresent()) {
129                     return;
130                 }
131                 /* Get and Validate TransactionCacheContainer */
132                 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
133                 if ( ! isTransactionCacheContainerValid(txContainer)) {
134                     return;
135                 }
136
137                 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
138                 /* Prepare List actual Meters and not updated Meters will be removed */
139                 final List<Meter> existMeters = fNode.get().getMeter() != null
140                         ? fNode.get().getMeter() : Collections.<Meter> emptyList();
141                 final List<MeterKey> existMeterKeys = new ArrayList<>();
142                 for (final Meter meter : existMeters) {
143                     existMeterKeys.add(meter.getKey());
144                 }
145                 /* MeterConfig processing */
146                 comitConfMeterStats(txContainer, tx, fNodeIdent, existMeterKeys);
147                 /* Delete all not presented Meter Nodes */
148                 deleteAllNotPresentedNodes(fNodeIdent, tx, Collections.unmodifiableList(existMeterKeys));
149                 /* Notification for continue collecting statistics */
150                 notifyToCollectNextStatistics(nodeIdent, transId);
151             }
152
153             public UUID generatedUUIDForNode() {
154                 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
155             }
156         });
157     }
158
159     @Override
160     public void onMeterFeaturesUpdated(final MeterFeaturesUpdated notification) {
161         Preconditions.checkNotNull(notification);
162         final TransactionId transId = notification.getTransactionId();
163         final NodeId nodeId = notification.getId();
164         if ( ! isExpectedStatistics(transId, nodeId)) {
165             LOG.debug("STAT-MANAGER - MeterFeaturesUpdated: unregistred notification detect TransactionId {}", transId);
166             return;
167         }
168         manager.getRpcMsgManager().addNotification(notification, nodeId);
169         if (notification.isMoreReplies()) {
170             return;
171         }
172
173         /* Don't block RPC Notification thread */
174         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
175             @Override
176             public void applyOperation(final ReadWriteTransaction tx) {
177                 /* Get and Validate TransactionCacheContainer */
178                 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
179                 if ( ! isTransactionCacheContainerValid(txContainer)) {
180                     return;
181                 }
182
183                 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
184                         .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
185
186                 //Register meter feature irrespective of whether this instance is
187                 //master instance of the device or not. In cluster mode, all instances
188                 // should have knowledge if meter is supported by the device.
189                 manager.registerAdditionalNodeFeature(nodeIdent, StatCapabTypes.METER_STATS);
190
191                 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
192
193                 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
194                 for (final TransactionAware notif : cacheNotifs) {
195                     if ( ! (notif instanceof MeterFeaturesUpdated)) {
196                         break;
197                     }
198                     final MeterFeatures stats = new MeterFeaturesBuilder((MeterFeaturesUpdated)notif).build();
199                     final InstanceIdentifier<NodeMeterFeatures> nodeMeterFeatureIdent =
200                             nodeIdent.augmentation(NodeMeterFeatures.class);
201                     final InstanceIdentifier<MeterFeatures> meterFeatureIdent = nodeMeterFeatureIdent
202                             .child(MeterFeatures.class);
203                     Optional<Node> node = Optional.absent();
204                     try {
205                         node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
206                     }
207                     catch (final ReadFailedException e) {
208                         LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
209                     }
210                     if (node.isPresent()) {
211                         tx.merge(LogicalDatastoreType.OPERATIONAL, nodeMeterFeatureIdent, new NodeMeterFeaturesBuilder().build(), true);
212                         tx.put(LogicalDatastoreType.OPERATIONAL, meterFeatureIdent, stats);
213                         manager.unregisterNodeStats(nodeIdent, StatCapabTypes.METER_FEATURE_STATS);
214                     } else {
215                         LOG.debug("Node {} is NOT present in the operational data store",nodeId);
216                     }
217                 }
218             }
219
220             @Override
221             public UUID generatedUUIDForNode() {
222                 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
223             }
224         });
225     }
226
227     @Override
228     public void onMeterStatisticsUpdated(final MeterStatisticsUpdated notification) {
229         Preconditions.checkNotNull(notification);
230         final TransactionId transId = notification.getTransactionId();
231         final NodeId nodeId = notification.getId();
232         if ( ! isExpectedStatistics(transId, nodeId)) {
233             LOG.debug("STAT-MANAGER - MeterStatisticsUpdated: unregistred notification detect TransactionId {}", transId);
234             return;
235         }
236         manager.getRpcMsgManager().addNotification(notification, nodeId);
237         if (notification.isMoreReplies()) {
238             return;
239         }
240
241         /* Don't block RPC Notification thread */
242         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
243             @Override
244             public void applyOperation(final ReadWriteTransaction tx) {
245
246                 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
247                         .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
248                 /* Node exist check */
249                 Optional<Node> node = Optional.absent();
250                 try {
251                     node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
252                 }
253                 catch (final ReadFailedException e) {
254                     LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
255                 }
256                 if ( ! node.isPresent()) {
257                     return;
258                 }
259
260                 /* Get and Validate TransactionCacheContainer */
261                 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
262                 if ( ! isTransactionCacheContainerValid(txContainer)) {
263                     return;
264                 }
265                 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
266
267                 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
268
269                 Optional<Meter> notifMeter = Optional.absent();
270                 final Optional<? extends DataObject> inputObj = txContainer.get().getConfInput();
271                 if (inputObj.isPresent() && inputObj.get() instanceof Meter) {
272                     notifMeter = Optional.<Meter> of((Meter)inputObj.get());
273                 }
274                 for (final TransactionAware notif : cacheNotifs) {
275                     if ( ! (notif instanceof MeterStatisticsUpdated)) {
276                         break;
277                     }
278                     statMeterCommit(((MeterStatisticsUpdated) notif).getMeterStats(), nodeIdent, tx);
279                 }
280                 if ( ! notifMeter.isPresent()) {
281                     notifyToCollectNextStatistics(nodeIdent, transId);
282                 }
283             }
284
285             @Override
286             public UUID generatedUUIDForNode() {
287                 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
288             }
289         });
290     }
291
292     private void statMeterCommit(final List<MeterStats> meterStats,
293             final InstanceIdentifier<Node> nodeIdent, final ReadWriteTransaction tx) {
294
295         Preconditions.checkNotNull(meterStats);
296         Preconditions.checkNotNull(nodeIdent);
297         Preconditions.checkNotNull(tx);
298
299         final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
300
301         for (final MeterStats mStat : meterStats) {
302             final MeterStatistics stats = new MeterStatisticsBuilder(mStat).build();
303
304             final InstanceIdentifier<Meter> meterIdent = fNodeIdent.child(Meter.class, new MeterKey(mStat.getMeterId()));
305             final InstanceIdentifier<NodeMeterStatistics> nodeMeterStatIdent = meterIdent
306                     .augmentation(NodeMeterStatistics.class);
307             final InstanceIdentifier<MeterStatistics> msIdent = nodeMeterStatIdent.child(MeterStatistics.class);
308             /* Meter Statistics commit */
309             Optional<Meter> meter = Optional.absent();
310             try {
311                 meter = tx.read(LogicalDatastoreType.OPERATIONAL, meterIdent).checkedGet();
312             }
313             catch (final ReadFailedException e) {
314                 LOG.debug("Read Operational/DS for FlowCapableNode fail! {}", fNodeIdent, e);
315             }
316             if (meter.isPresent()) {
317                 tx.merge(LogicalDatastoreType.OPERATIONAL, nodeMeterStatIdent, new NodeMeterStatisticsBuilder().build(), true);
318                 tx.put(LogicalDatastoreType.OPERATIONAL, msIdent, stats);
319             }
320         }
321     }
322
323     private void comitConfMeterStats(final Optional<TransactionCacheContainer<?>> txContainer, final ReadWriteTransaction tx,
324             final InstanceIdentifier<FlowCapableNode> fNodeIdent, final List<MeterKey> existMeterKeys) {
325
326         Preconditions.checkNotNull(existMeterKeys);
327         Preconditions.checkNotNull(txContainer);
328         Preconditions.checkNotNull(fNodeIdent);
329         Preconditions.checkNotNull(tx);
330
331         final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
332         for (final TransactionAware notif : cacheNotifs) {
333             if ( ! (notif instanceof MeterConfigStatsUpdated)) {
334                 break;
335             }
336             final List<MeterConfigStats> meterStats = ((MeterConfigStatsUpdated) notif).getMeterConfigStats();
337             if (meterStats == null) {
338                 break;
339             }
340             for (final MeterConfigStats meterStat : meterStats) {
341                 if (meterStat.getMeterId() != null) {
342                     final MeterBuilder meterBuilder = new MeterBuilder(meterStat);
343                     final MeterKey meterKey = new MeterKey(meterStat.getMeterId());
344                     final InstanceIdentifier<Meter> meterRef = fNodeIdent.child(Meter.class, meterKey);
345
346                     final NodeMeterConfigStatsBuilder meterConfig = new NodeMeterConfigStatsBuilder();
347                     meterConfig.setMeterConfigStats(new MeterConfigStatsBuilder(meterStat).build());
348                     //Update augmented data
349                     meterBuilder.addAugmentation(NodeMeterConfigStats.class, meterConfig.build());
350                     existMeterKeys.remove(meterKey);
351                     tx.put(LogicalDatastoreType.OPERATIONAL, meterRef, meterBuilder.build());
352                 }
353             }
354         }
355     }
356
357     private void deleteAllNotPresentedNodes(final InstanceIdentifier<FlowCapableNode> fNodeIdent,
358             final ReadWriteTransaction tx, final List<MeterKey> deviceMeterKeys) {
359
360         Preconditions.checkNotNull(fNodeIdent);
361         Preconditions.checkNotNull(tx);
362
363         if (deviceMeterKeys == null) {
364             return;
365         }
366
367         for (final MeterKey key : deviceMeterKeys) {
368             final InstanceIdentifier<Meter> delMeterIdent = fNodeIdent.child(Meter.class, key);
369             LOG.trace("Meter {} has to removed.", key);
370             Optional<Meter> delMeter = Optional.absent();
371             try {
372                 delMeter = tx.read(LogicalDatastoreType.OPERATIONAL, delMeterIdent).checkedGet();
373             }
374             catch (final ReadFailedException e) {
375                 // NOOP - probably another transaction delete that node
376                 LOG.debug("Meter {} was probably deleted via other transaction. Exception {}", delMeterIdent, e);
377             }
378             if (delMeter.isPresent()) {
379                 tx.delete(LogicalDatastoreType.OPERATIONAL, delMeterIdent);
380             }
381         }
382     }
383 }
384