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.openflowplugin.applications.statistics.manager.impl;
11 import java.util.ArrayList;
12 import java.util.Collection;
13 import java.util.Collections;
14 import java.util.List;
16 import java.util.UUID;
17 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
18 import org.opendaylight.controller.md.sal.binding.api.DataObjectModification;
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.tables.table.Flow;
32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.TransactionAware;
33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.TransactionId;
34 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupDescStatsUpdated;
35 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupFeaturesUpdated;
36 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupStatisticsUpdated;
37 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStats;
38 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStatsBuilder;
39 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeatures;
40 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeaturesBuilder;
41 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatistics;
42 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatisticsBuilder;
43 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.OpendaylightGroupStatisticsListener;
44 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.desc.GroupDescBuilder;
45 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.features.GroupFeatures;
46 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.features.GroupFeaturesBuilder;
47 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.statistics.GroupStatistics;
48 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.statistics.GroupStatisticsBuilder;
49 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.desc.stats.reply.GroupDescStats;
50 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStats;
51 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
52 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
53 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
54 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
55 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
56 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
57 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
58 import org.opendaylight.yangtools.yang.binding.DataObject;
59 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
60 import org.slf4j.Logger;
61 import org.slf4j.LoggerFactory;
63 import com.google.common.base.Optional;
64 import com.google.common.base.Preconditions;
68 * org.opendaylight.openflowplugin.applications.statistics.manager.impl
70 * StatListenCommitGroup
71 * Class is a NotifyListener for GroupStatistics and DataTreeChangeListener for Config/DataStore for Group node.
72 * All expected (registered) GroupStatistics will be builded and commit to Operational/DataStore.
73 * DataTreeModification should call create/delete Group in Operational/DS
75 public class StatListenCommitGroup extends StatAbstractListenCommit<Group, OpendaylightGroupStatisticsListener>
76 implements OpendaylightGroupStatisticsListener {
78 private static final Logger LOG = LoggerFactory.getLogger(StatListenCommitGroup.class);
80 public StatListenCommitGroup(final StatisticsManager manager, final DataBroker db,
81 final NotificationProviderService nps,
82 final StatNodeRegistration nrm) {
83 super(manager, db, nps, Group.class,nrm);
87 protected OpendaylightGroupStatisticsListener getStatNotificationListener() {
92 protected InstanceIdentifier<Group> getWildCardedRegistrationPath() {
93 return InstanceIdentifier.create(Nodes.class).child(Node.class)
94 .augmentation(FlowCapableNode.class).child(Group.class);
98 protected void processDataChange(Collection<DataTreeModification<Group>> changes) {
103 public void onGroupDescStatsUpdated(final GroupDescStatsUpdated notification) {
104 final TransactionId transId = notification.getTransactionId();
105 final NodeId nodeId = notification.getId();
106 if ( ! isExpectedStatistics(transId, nodeId)) {
107 LOG.debug("Unregistred notification detect TransactionId {}", transId);
110 manager.getRpcMsgManager().addNotification(notification, nodeId);
111 if (notification.isMoreReplies()) {
115 /* Don't block RPC Notification thread */
116 manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
118 public void applyOperation(final ReadWriteTransaction tx) {
119 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
120 .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
121 /* Validate exist FlowCapableNode */
122 final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
123 Optional<FlowCapableNode> fNode = Optional.absent();
125 fNode = tx.read(LogicalDatastoreType.OPERATIONAL,fNodeIdent).checkedGet();
127 catch (final ReadFailedException e) {
128 LOG.debug("Read Operational/DS for FlowCapableNode fail! {}", fNodeIdent, e);
130 if ( ! fNode.isPresent()) {
133 /* Get and Validate TransactionCacheContainer */
134 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
135 if ( ! isTransactionCacheContainerValid(txContainer)) {
139 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
141 /* Prepare List actual Groups and not updated Groups will be removed */
142 final List<Group> existGroups = fNode.get().getGroup() != null
143 ? fNode.get().getGroup() : Collections.<Group> emptyList();
144 final List<GroupKey> existGroupKeys = new ArrayList<>();
145 for (final Group group : existGroups) {
146 existGroupKeys.add(group.getKey());
148 /* GroupDesc processing */
149 statGroupDescCommit(txContainer, tx, fNodeIdent, existGroupKeys);
150 /* Delete all not presented Group Nodes */
151 deleteAllNotPresentNode(fNodeIdent, tx, Collections.unmodifiableList(existGroupKeys));
152 /* Notification for continue collecting statistics */
153 notifyToCollectNextStatistics(nodeIdent, transId);
157 public UUID generatedUUIDForNode() {
158 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
164 public void onGroupFeaturesUpdated(final GroupFeaturesUpdated notification) {
165 Preconditions.checkNotNull(notification);
166 final TransactionId transId = notification.getTransactionId();
167 final NodeId nodeId = notification.getId();
168 if ( ! isExpectedStatistics(transId, nodeId)) {
169 LOG.debug("Unregistred notification detect TransactionId {}", transId);
172 manager.getRpcMsgManager().addNotification(notification, nodeId);
173 if (notification.isMoreReplies()) {
177 /* Don't block RPC Notification thread */
178 manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
180 public void applyOperation(final ReadWriteTransaction tx) {
181 /* Get and Validate TransactionCacheContainer */
182 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
183 if ( ! isTransactionCacheContainerValid(txContainer)) {
187 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
188 .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
190 manager.registerAdditionalNodeFeature(nodeIdent, StatCapabTypes.GROUP_STATS);
192 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
194 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
195 for (final TransactionAware notif : cacheNotifs) {
196 if ( ! (notif instanceof GroupFeaturesUpdated)) {
199 final GroupFeatures stats = new GroupFeaturesBuilder((GroupFeaturesUpdated)notif).build();
200 final InstanceIdentifier<NodeGroupFeatures> nodeGroupFeatureIdent =
201 nodeIdent.augmentation(NodeGroupFeatures.class);
202 final InstanceIdentifier<GroupFeatures> groupFeatureIdent = nodeGroupFeatureIdent
203 .child(GroupFeatures.class);
204 Optional<Node> node = Optional.absent();
206 node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
208 catch (final ReadFailedException e) {
209 LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
211 if (node.isPresent()) {
212 tx.merge(LogicalDatastoreType.OPERATIONAL, nodeGroupFeatureIdent, new NodeGroupFeaturesBuilder().build(), true);
213 tx.put(LogicalDatastoreType.OPERATIONAL, groupFeatureIdent, stats);
214 manager.unregisterNodeStats(nodeIdent, StatCapabTypes.GROUP_FEATURE_STATS);
216 LOG.debug("Node {} is NOT present in the operational data store",nodeId);
222 public UUID generatedUUIDForNode() {
223 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
229 public void onGroupStatisticsUpdated(final GroupStatisticsUpdated notification) {
230 Preconditions.checkNotNull(notification);
231 final TransactionId transId = notification.getTransactionId();
232 final NodeId nodeId = notification.getId();
233 if ( ! isExpectedStatistics(transId, nodeId)) {
234 LOG.debug("STAT-MANAGER - GroupStatisticsUpdated: unregistred notification detect TransactionId {}", transId);
237 manager.getRpcMsgManager().addNotification(notification, nodeId);
238 if (notification.isMoreReplies()) {
242 /* Don't block RPC Notification thread */
243 manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
245 public void applyOperation(final ReadWriteTransaction tx) {
247 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
248 .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
249 /* Node exist check */
250 Optional<Node> node = Optional.absent();
252 node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
254 catch (final ReadFailedException e) {
255 LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
257 if ( ! node.isPresent()) {
261 /* Get and Validate TransactionCacheContainer */
262 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
263 if ( ! isTransactionCacheContainerValid(txContainer)) {
267 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
269 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
271 Optional<Group> notifGroup = Optional.absent();
272 final Optional<? extends DataObject> inputObj = txContainer.get().getConfInput();
273 if (inputObj.isPresent() && inputObj.get() instanceof Group) {
274 notifGroup = Optional.<Group> of((Group)inputObj.get());
276 for (final TransactionAware notif : cacheNotifs) {
277 if ( ! (notif instanceof GroupStatisticsUpdated)) {
280 statGroupCommit(((GroupStatisticsUpdated) notif).getGroupStats(), nodeIdent, tx);
282 if ( ! notifGroup.isPresent()) {
283 notifyToCollectNextStatistics(nodeIdent, transId);
287 public UUID generatedUUIDForNode() {
288 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
293 private void statGroupCommit(final List<GroupStats> groupStats, final InstanceIdentifier<Node> nodeIdent,
294 final ReadWriteTransaction tx) {
296 Preconditions.checkNotNull(groupStats);
297 Preconditions.checkNotNull(nodeIdent);
298 Preconditions.checkNotNull(tx);
300 final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
302 for (final GroupStats gStat : groupStats) {
303 final GroupStatistics stats = new GroupStatisticsBuilder(gStat).build();
305 final InstanceIdentifier<Group> groupIdent = fNodeIdent.child(Group.class, new GroupKey(gStat.getGroupId()));
306 final InstanceIdentifier<NodeGroupStatistics> nGroupStatIdent =groupIdent
307 .augmentation(NodeGroupStatistics.class);
308 final InstanceIdentifier<GroupStatistics> gsIdent = nGroupStatIdent.child(GroupStatistics.class);
309 /* Statistics Writing */
310 Optional<Group> group = Optional.absent();
312 group = tx.read(LogicalDatastoreType.OPERATIONAL, groupIdent).checkedGet();
314 catch (final ReadFailedException e) {
315 LOG.debug("Read Operational/DS for Group node fail! {}", groupIdent, e);
317 if (group.isPresent()) {
318 tx.merge(LogicalDatastoreType.OPERATIONAL, nGroupStatIdent, new NodeGroupStatisticsBuilder().build(), true);
319 tx.put(LogicalDatastoreType.OPERATIONAL, gsIdent, stats);
324 private void statGroupDescCommit(final Optional<TransactionCacheContainer<?>> txContainer, final ReadWriteTransaction tx,
325 final InstanceIdentifier<FlowCapableNode> fNodeIdent, final List<GroupKey> existGroupKeys) {
327 Preconditions.checkNotNull(existGroupKeys);
328 Preconditions.checkNotNull(txContainer);
329 Preconditions.checkNotNull(fNodeIdent);
330 Preconditions.checkNotNull(tx);
332 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
333 for (final TransactionAware notif : cacheNotifs) {
334 if ( ! (notif instanceof GroupDescStatsUpdated)) {
337 final List<GroupDescStats> groupStats = ((GroupDescStatsUpdated) notif).getGroupDescStats();
338 if (groupStats == null) {
341 for (final GroupDescStats group : groupStats) {
342 if (group.getGroupId() != null) {
343 final GroupBuilder groupBuilder = new GroupBuilder(group);
344 final GroupKey groupKey = new GroupKey(group.getGroupId());
345 final InstanceIdentifier<Group> groupRef = fNodeIdent.child(Group.class,groupKey);
347 final NodeGroupDescStatsBuilder groupDesc= new NodeGroupDescStatsBuilder();
348 groupDesc.setGroupDesc(new GroupDescBuilder(group).build());
349 //Update augmented data
350 groupBuilder.addAugmentation(NodeGroupDescStats.class, groupDesc.build());
351 existGroupKeys.remove(groupKey);
352 tx.put(LogicalDatastoreType.OPERATIONAL, groupRef, groupBuilder.build());
358 private void deleteAllNotPresentNode(final InstanceIdentifier<FlowCapableNode> fNodeIdent,
359 final ReadWriteTransaction trans, final List<GroupKey> deviceGroupKeys) {
361 Preconditions.checkNotNull(fNodeIdent);
362 Preconditions.checkNotNull(trans);
364 if (deviceGroupKeys == null) {
368 for (final GroupKey key : deviceGroupKeys) {
369 final InstanceIdentifier<Group> delGroupIdent = fNodeIdent.child(Group.class, key);
370 LOG.trace("Group {} has to removed.", key);
371 Optional<Group> delGroup = Optional.absent();
373 delGroup = trans.read(LogicalDatastoreType.OPERATIONAL, delGroupIdent).checkedGet();
375 catch (final ReadFailedException e) {
376 // NOOP - probably another transaction delete that node
377 LOG.debug("Group {} was probably deleted via other transaction. Exception {}", delGroupIdent, e);
379 if (delGroup.isPresent()) {
380 trans.delete(LogicalDatastoreType.OPERATIONAL, delGroupIdent);