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