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