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