applications/statistics-manager/src/main/java/org/opendaylight/openflowplugin/applications/statistics/manager/impl/StatListenCommitGroup.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 java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.List;
  14
  15 import java.util.UUID;
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  18 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  19 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  20 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
  21 import org.opendaylight.openflowplugin.applications.statistics.manager.StatNodeRegistration;
  22 import org.opendaylight.openflowplugin.applications.statistics.manager.StatPermCollector.StatCapabTypes;
  23 import org.opendaylight.openflowplugin.applications.statistics.manager.StatRpcMsgManager.TransactionCacheContainer;
  24 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager;
  25 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager.StatDataStoreOperation;
  26 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager.StatDataStoreOperation.StatsManagerOperationType;
  27 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.TransactionAware;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.transaction.rev150304.TransactionId;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupDescStatsUpdated;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupFeaturesUpdated;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.GroupStatisticsUpdated;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStats;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupDescStatsBuilder;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeatures;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupFeaturesBuilder;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatistics;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.NodeGroupStatisticsBuilder;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.OpendaylightGroupStatisticsListener;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.desc.GroupDescBuilder;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.features.GroupFeatures;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.features.GroupFeaturesBuilder;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.statistics.GroupStatistics;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.statistics.rev131111.group.statistics.GroupStatisticsBuilder;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.desc.stats.reply.GroupDescStats;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.group.statistics.reply.GroupStats;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.Group;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupBuilder;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.group.types.rev131018.groups.GroupKey;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  52 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  53 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  54 import org.opendaylight.yangtools.yang.binding.DataObject;
  55 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  56 import org.slf4j.Logger;
  57 import org.slf4j.LoggerFactory;
  58
  59 import com.google.common.base.Optional;
  60 import com.google.common.base.Preconditions;
  61
  62 /**
  63  * statistics-manager
  64  * org.opendaylight.openflowplugin.applications.statistics.manager.impl
  65  *
  66  * StatListenCommitGroup
  67  * Class is a NotifyListener for GroupStatistics and DataChangeListener for Config/DataStore for Group node.
  68  * All expected (registered) GroupStatistics will be builded and commit to Operational/DataStore.
  69  * DataChangeEven should call create/delete Group in Operational/DS
  70  *
  71  * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
  72  *
  73  */
  74 public class StatListenCommitGroup extends StatAbstractListenCommit<Group, OpendaylightGroupStatisticsListener>
  75                                                     implements OpendaylightGroupStatisticsListener {
  76
  77     private static final Logger LOG = LoggerFactory.getLogger(StatListenCommitGroup.class);
  78
  79     public StatListenCommitGroup(final StatisticsManager manager,  final DataBroker db,
  80             final NotificationProviderService nps,
  81                                  final StatNodeRegistration nrm) {
  82         super(manager, db, nps, Group.class,nrm);
  83     }
  84
  85     @Override
  86     protected OpendaylightGroupStatisticsListener getStatNotificationListener() {
  87         return this;
  88     }
  89
  90     @Override
  91     protected InstanceIdentifier<Group> getWildCardedRegistrationPath() {
  92         return InstanceIdentifier.create(Nodes.class).child(Node.class)
  93                 .augmentation(FlowCapableNode.class).child(Group.class);
  94     }
  95
  96     @Override
  97     public void onGroupDescStatsUpdated(final GroupDescStatsUpdated notification) {
  98         final TransactionId transId = notification.getTransactionId();
  99         final NodeId nodeId = notification.getId();
 100         if ( ! isExpectedStatistics(transId, nodeId)) {
 101             LOG.debug("Unregistred notification detect TransactionId {}", transId);
 102             return;
 103         }
 104         manager.getRpcMsgManager().addNotification(notification, nodeId);
 105         if (notification.isMoreReplies()) {
 106             return;
 107         }
 108
 109         /* Don't block RPC Notification thread */
 110         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
 111             @Override
 112             public void applyOperation(final ReadWriteTransaction tx) {
 113                 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
 114                         .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
 115                 /* Validate exist FlowCapableNode */
 116                 final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
 117                 Optional<FlowCapableNode> fNode = Optional.absent();
 118                 try {
 119                     fNode = tx.read(LogicalDatastoreType.OPERATIONAL,fNodeIdent).checkedGet();
 120                 }
 121                 catch (final ReadFailedException e) {
 122                     LOG.debug("Read Operational/DS for FlowCapableNode fail! {}", fNodeIdent, e);
 123                 }
 124                 if ( ! fNode.isPresent()) {
 125                     return;
 126                 }
 127                 /* Get and Validate TransactionCacheContainer */
 128                 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
 129                 if ( ! isTransactionCacheContainerValid(txContainer)) {
 130                     return;
 131                 }
 132
 133                 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
 134
 135                 /* Prepare List actual Groups and not updated Groups will be removed */
 136                 final List<Group> existGroups = fNode.get().getGroup() != null
 137                         ? fNode.get().getGroup() : Collections.<Group> emptyList();
 138                 final List<GroupKey> existGroupKeys = new ArrayList<>();
 139                 for (final Group group : existGroups) {
 140                     existGroupKeys.add(group.getKey());
 141                 }
 142                 /* GroupDesc processing */
 143                 statGroupDescCommit(txContainer, tx, fNodeIdent, existGroupKeys);
 144                 /* Delete all not presented Group Nodes */
 145                 deleteAllNotPresentNode(fNodeIdent, tx, Collections.unmodifiableList(existGroupKeys));
 146                 /* Notification for continue collecting statistics */
 147                 notifyToCollectNextStatistics(nodeIdent, transId);
 148             }
 149
 150             @Override
 151             public UUID generatedUUIDForNode() {
 152                 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
 153             }
 154         });
 155     }
 156
 157     @Override
 158     public void onGroupFeaturesUpdated(final GroupFeaturesUpdated notification) {
 159         Preconditions.checkNotNull(notification);
 160         final TransactionId transId = notification.getTransactionId();
 161         final NodeId nodeId = notification.getId();
 162         if ( ! isExpectedStatistics(transId, nodeId)) {
 163             LOG.debug("Unregistred notification detect TransactionId {}", transId);
 164             return;
 165         }
 166         manager.getRpcMsgManager().addNotification(notification, nodeId);
 167         if (notification.isMoreReplies()) {
 168             return;
 169         }
 170
 171         /* Don't block RPC Notification thread */
 172         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
 173             @Override
 174             public void applyOperation(final ReadWriteTransaction tx) {
 175                 /* Get and Validate TransactionCacheContainer */
 176                 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
 177                 if ( ! isTransactionCacheContainerValid(txContainer)) {
 178                     return;
 179                 }
 180
 181                 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
 182                         .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
 183
 184                 manager.registerAdditionalNodeFeature(nodeIdent, StatCapabTypes.GROUP_STATS);
 185
 186                 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
 187
 188                 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
 189                 for (final TransactionAware notif : cacheNotifs) {
 190                     if ( ! (notif instanceof GroupFeaturesUpdated)) {
 191                         break;
 192                     }
 193                     final GroupFeatures stats = new GroupFeaturesBuilder((GroupFeaturesUpdated)notif).build();
 194                     final InstanceIdentifier<NodeGroupFeatures> nodeGroupFeatureIdent =
 195                             nodeIdent.augmentation(NodeGroupFeatures.class);
 196                     final InstanceIdentifier<GroupFeatures> groupFeatureIdent = nodeGroupFeatureIdent
 197                             .child(GroupFeatures.class);
 198                     Optional<Node> node = Optional.absent();
 199                     try {
 200                         node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
 201                     }
 202                     catch (final ReadFailedException e) {
 203                         LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
 204                     }
 205                     if (node.isPresent()) {
 206                         tx.merge(LogicalDatastoreType.OPERATIONAL, nodeGroupFeatureIdent, new NodeGroupFeaturesBuilder().build(), true);
 207                         tx.put(LogicalDatastoreType.OPERATIONAL, groupFeatureIdent, stats);
 208                         manager.unregisterNodeStats(nodeIdent, StatCapabTypes.GROUP_FEATURE_STATS);
 209                     } else {
 210                         LOG.debug("Node {} is NOT present in the operational data store",nodeId);
 211                     }
 212                 }
 213             }
 214
 215             @Override
 216             public UUID generatedUUIDForNode() {
 217                 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
 218             }
 219         });
 220     }
 221
 222     @Override
 223     public void onGroupStatisticsUpdated(final GroupStatisticsUpdated notification) {
 224         Preconditions.checkNotNull(notification);
 225         final TransactionId transId = notification.getTransactionId();
 226         final NodeId nodeId = notification.getId();
 227         if ( ! isExpectedStatistics(transId, nodeId)) {
 228             LOG.debug("STAT-MANAGER - GroupStatisticsUpdated: unregistred notification detect TransactionId {}", transId);
 229             return;
 230         }
 231         manager.getRpcMsgManager().addNotification(notification, nodeId);
 232         if (notification.isMoreReplies()) {
 233             return;
 234         }
 235
 236         /* Don't block RPC Notification thread */
 237         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
 238             @Override
 239             public void applyOperation(final ReadWriteTransaction tx) {
 240
 241                 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier
 242                         .create(Nodes.class).child(Node.class, new NodeKey(nodeId));
 243                 /* Node exist check */
 244                 Optional<Node> node = Optional.absent();
 245                 try {
 246                     node = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
 247                 }
 248                 catch (final ReadFailedException e) {
 249                     LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
 250                 }
 251                 if ( ! node.isPresent()) {
 252                     return;
 253                 }
 254
 255                 /* Get and Validate TransactionCacheContainer */
 256                 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
 257                 if ( ! isTransactionCacheContainerValid(txContainer)) {
 258                     return;
 259                 }
 260
 261                 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
 262
 263                 final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
 264
 265                 Optional<Group> notifGroup = Optional.absent();
 266                 final Optional<? extends DataObject> inputObj = txContainer.get().getConfInput();
 267                 if (inputObj.isPresent() && inputObj.get() instanceof Group) {
 268                     notifGroup = Optional.<Group> of((Group)inputObj.get());
 269                 }
 270                 for (final TransactionAware notif : cacheNotifs) {
 271                     if ( ! (notif instanceof GroupStatisticsUpdated)) {
 272                         break;
 273                     }
 274                     statGroupCommit(((GroupStatisticsUpdated) notif).getGroupStats(), nodeIdent, tx);
 275                 }
 276                 if ( ! notifGroup.isPresent()) {
 277                     notifyToCollectNextStatistics(nodeIdent, transId);
 278                 }
 279             }
 280
 281             public UUID generatedUUIDForNode() {
 282                 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
 283             }
 284         });
 285     }
 286
 287     private void statGroupCommit(final List<GroupStats> groupStats, final InstanceIdentifier<Node> nodeIdent,
 288             final ReadWriteTransaction tx) {
 289
 290         Preconditions.checkNotNull(groupStats);
 291         Preconditions.checkNotNull(nodeIdent);
 292         Preconditions.checkNotNull(tx);
 293
 294         final InstanceIdentifier<FlowCapableNode> fNodeIdent = nodeIdent.augmentation(FlowCapableNode.class);
 295
 296         for (final GroupStats gStat : groupStats) {
 297             final GroupStatistics stats = new GroupStatisticsBuilder(gStat).build();
 298
 299             final InstanceIdentifier<Group> groupIdent = fNodeIdent.child(Group.class, new GroupKey(gStat.getGroupId()));
 300             final InstanceIdentifier<NodeGroupStatistics> nGroupStatIdent =groupIdent
 301                     .augmentation(NodeGroupStatistics.class);
 302             final InstanceIdentifier<GroupStatistics> gsIdent = nGroupStatIdent.child(GroupStatistics.class);
 303             /* Statistics Writing */
 304             Optional<Group> group = Optional.absent();
 305             try {
 306                 group = tx.read(LogicalDatastoreType.OPERATIONAL, groupIdent).checkedGet();
 307             }
 308             catch (final ReadFailedException e) {
 309                 LOG.debug("Read Operational/DS for Group node fail! {}", groupIdent, e);
 310             }
 311             if (group.isPresent()) {
 312                 tx.merge(LogicalDatastoreType.OPERATIONAL, nGroupStatIdent, new NodeGroupStatisticsBuilder().build(), true);
 313                 tx.put(LogicalDatastoreType.OPERATIONAL, gsIdent, stats);
 314             }
 315         }
 316     }
 317
 318     private void statGroupDescCommit(final Optional<TransactionCacheContainer<?>> txContainer, final ReadWriteTransaction tx,
 319             final InstanceIdentifier<FlowCapableNode> fNodeIdent, final List<GroupKey> existGroupKeys) {
 320
 321         Preconditions.checkNotNull(existGroupKeys);
 322         Preconditions.checkNotNull(txContainer);
 323         Preconditions.checkNotNull(fNodeIdent);
 324         Preconditions.checkNotNull(tx);
 325
 326         final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
 327         for (final TransactionAware notif : cacheNotifs) {
 328             if ( ! (notif instanceof GroupDescStatsUpdated)) {
 329                 break;
 330             }
 331             final List<GroupDescStats> groupStats = ((GroupDescStatsUpdated) notif).getGroupDescStats();
 332             if (groupStats == null) {
 333                 break;
 334             }
 335             for (final GroupDescStats group : groupStats) {
 336                 if (group.getGroupId() != null) {
 337                     final GroupBuilder groupBuilder = new GroupBuilder(group);
 338                     final GroupKey groupKey = new GroupKey(group.getGroupId());
 339                     final InstanceIdentifier<Group> groupRef = fNodeIdent.child(Group.class,groupKey);
 340
 341                     final NodeGroupDescStatsBuilder groupDesc= new NodeGroupDescStatsBuilder();
 342                     groupDesc.setGroupDesc(new GroupDescBuilder(group).build());
 343                     //Update augmented data
 344                     groupBuilder.addAugmentation(NodeGroupDescStats.class, groupDesc.build());
 345                     existGroupKeys.remove(groupKey);
 346                     tx.put(LogicalDatastoreType.OPERATIONAL, groupRef, groupBuilder.build());
 347                 }
 348             }
 349         }
 350     }
 351
 352     private void deleteAllNotPresentNode(final InstanceIdentifier<FlowCapableNode> fNodeIdent,
 353             final ReadWriteTransaction trans, final List<GroupKey> deviceGroupKeys) {
 354
 355         Preconditions.checkNotNull(fNodeIdent);
 356         Preconditions.checkNotNull(trans);
 357
 358         if (deviceGroupKeys == null) {
 359             return;
 360         }
 361
 362         for (final GroupKey key : deviceGroupKeys) {
 363             final InstanceIdentifier<Group> delGroupIdent = fNodeIdent.child(Group.class, key);
 364             LOG.trace("Group {} has to removed.", key);
 365             Optional<Group> delGroup = Optional.absent();
 366             try {
 367                 delGroup = trans.read(LogicalDatastoreType.OPERATIONAL, delGroupIdent).checkedGet();
 368             }
 369             catch (final ReadFailedException e) {
 370                 // NOOP - probably another transaction delete that node
 371                 LOG.debug("Group {} was probably deleted via other transaction. Exception {}", delGroupIdent, e);
 372             }
 373             if (delGroup.isPresent()) {
 374                 trans.delete(LogicalDatastoreType.OPERATIONAL, delGroupIdent);
 375             }
 376         }
 377     }
 378 }
 379