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