applications/statistics-manager/src/main/java/org/opendaylight/openflowplugin/applications/statistics/manager/impl/StatListenCommitQueue.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
  14 import java.util.Collection;
  15 import java.util.Collections;
  16 import java.util.HashMap;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Map.Entry;
  20
  21 import java.util.UUID;
  22 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  23 import org.opendaylight.controller.md.sal.binding.api.DataTreeModification;
  24 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  25 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  26 import org.opendaylight.controller.md.sal.common.api.data.ReadFailedException;
  27 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
  28 import org.opendaylight.openflowplugin.applications.statistics.manager.StatNodeRegistration;
  29 import org.opendaylight.openflowplugin.applications.statistics.manager.StatRpcMsgManager.TransactionCacheContainer;
  30 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager;
  31 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager.StatDataStoreOperation;
  32 import org.opendaylight.openflowplugin.applications.statistics.manager.StatisticsManager.StatDataStoreOperation.StatsManagerOperationType;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeConnector;
  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.flow.types.port.rev130925.queues.Queue;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.QueueBuilder;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.types.port.rev130925.queues.QueueKey;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeId;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnector;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.node.NodeConnectorKey;
  43 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.Node;
  44 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.nodes.NodeKey;
  45 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.FlowCapableNodeConnectorQueueStatisticsData;
  46 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.FlowCapableNodeConnectorQueueStatisticsDataBuilder;
  47 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.OpendaylightQueueStatisticsListener;
  48 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.QueueStatisticsUpdate;
  49 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.flow.capable.node.connector.queue.statistics.FlowCapableNodeConnectorQueueStatistics;
  50 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.flow.capable.node.connector.queue.statistics.FlowCapableNodeConnectorQueueStatisticsBuilder;
  51 import org.opendaylight.yang.gen.v1.urn.opendaylight.queue.statistics.rev131216.queue.id.and.statistics.map.QueueIdAndStatisticsMap;
  52 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55
  56 /**
  57  * statistics-manager
  58  * org.opendaylight.openflowplugin.applications.statistics.manager.impl
  59  *
  60  * StatNotifyCommitQueue
  61  * Class is a NotifyListner for Queues Statistics
  62  * All expected (registered) queueStatistics will be builded and
  63  * commit to Operational/DataStore
  64  *
  65  * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
  66  *
  67  */
  68 public class StatListenCommitQueue extends StatAbstractListenCommit<Queue, OpendaylightQueueStatisticsListener>
  69                                         implements OpendaylightQueueStatisticsListener {
  70
  71     private static final Logger LOG = LoggerFactory.getLogger(StatListenCommitQueue.class);
  72
  73     public StatListenCommitQueue(final StatisticsManager manager, final DataBroker db,
  74             final NotificationProviderService nps,
  75                                  final StatNodeRegistration nrm) {
  76         super(manager, db, nps, Queue.class,nrm);
  77     }
  78
  79     @Override
  80     protected OpendaylightQueueStatisticsListener getStatNotificationListener() {
  81         return this;
  82     }
  83
  84     @Override
  85     protected InstanceIdentifier<Queue> getWildCardedRegistrationPath() {
  86         return InstanceIdentifier.create(Nodes.class).child(Node.class).child(NodeConnector.class)
  87             .augmentation(FlowCapableNodeConnector.class).child(Queue.class);
  88     }
  89
  90     @Override
  91     protected void processDataChange(Collection<DataTreeModification<Queue>> changes) {
  92         //NO-OP
  93     }
  94
  95     @Override
  96     public void onQueueStatisticsUpdate(final QueueStatisticsUpdate notification) {
  97         final TransactionId transId = notification.getTransactionId();
  98         final NodeId nodeId = notification.getId();
  99         if ( ! isExpectedStatistics(transId, nodeId)) {
 100             LOG.debug("STAT-MANAGER - QueueStatisticsUpdate: unregistred notification detect TransactionId {}", transId);
 101             return;
 102         }
 103         manager.getRpcMsgManager().addNotification(notification, nodeId);
 104         if (notification.isMoreReplies()) {
 105             return;
 106         }
 107
 108         /* Don't block RPC Notification thread */
 109         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.DATA_COMMIT_OPER_DS,nodeId) {
 110             @Override
 111             public void applyOperation(final ReadWriteTransaction tx) {
 112
 113                 final InstanceIdentifier<Node> nodeIdent = InstanceIdentifier.create(Nodes.class)
 114                         .child(Node.class, new NodeKey(nodeId));
 115
 116                 /* Validate exist Node */
 117                 Optional<Node> fNode = Optional.absent();
 118                 try {
 119                     fNode = tx.read(LogicalDatastoreType.OPERATIONAL, nodeIdent).checkedGet();
 120                 }
 121                 catch (final ReadFailedException e) {
 122                     LOG.debug("Read Operational/DS for Node fail! {}", nodeIdent, e);
 123                 }
 124                 if ( ! fNode.isPresent()) {
 125                     LOG.trace("Read Operational/DS for Node fail! Node {} doesn't exist.", nodeIdent);
 126                     return;
 127                 }
 128
 129                 /* Get and Validate TransactionCacheContainer */
 130                 final Optional<TransactionCacheContainer<?>> txContainer = getTransactionCacheContainer(transId, nodeId);
 131                 if ( ! isTransactionCacheContainerValid(txContainer)) {
 132                     return;
 133                 }
 134
 135                 if(!nodeRegistrationManager.isFlowCapableNodeOwner(nodeId)) { return; }
 136
 137                 /* Prepare List actual Queues and not updated Queues will be removed */
 138                 final List<NodeConnector> existConnectors = fNode.get().getNodeConnector() != null
 139                         ? fNode.get().getNodeConnector() : Collections.<NodeConnector> emptyList();
 140                 final Map<QueueKey, NodeConnectorKey> existQueueKeys = new HashMap<>();
 141                 for (final NodeConnector connect : existConnectors) {
 142                     if(connect.getAugmentation(FlowCapableNodeConnector.class) != null){
 143                         final List<Queue> listQueues = connect.getAugmentation(FlowCapableNodeConnector.class).getQueue();
 144                         if (listQueues != null) {
 145                             for (final Queue queue : listQueues) {
 146                                 existQueueKeys.put(queue.getKey(), connect.getKey());
 147                             }
 148                         }
 149                     }
 150                 }
 151                 /* Queue processing */
 152                 statQueueCommit(txContainer, tx, nodeIdent, existQueueKeys);
 153                 /* Delete all not presented Group Nodes */
 154                 deleteAllNotPresentedNodes(nodeIdent, tx, Collections.unmodifiableMap(existQueueKeys));
 155                 /* Notification for continue collecting statistics */
 156                 notifyToCollectNextStatistics(nodeIdent, transId);
 157             }
 158
 159             @Override
 160             public UUID generatedUUIDForNode() {
 161                 return manager.getGeneratedUUIDForNode(getNodeIdentifier());
 162             }
 163         });
 164     }
 165
 166     private void statQueueCommit(
 167             final Optional<TransactionCacheContainer<?>> txContainer, final ReadWriteTransaction tx,
 168             final InstanceIdentifier<Node> nodeIdent, final Map<QueueKey, NodeConnectorKey> existQueueKeys) {
 169
 170         Preconditions.checkNotNull(existQueueKeys);
 171         Preconditions.checkNotNull(txContainer);
 172         Preconditions.checkNotNull(nodeIdent);
 173         Preconditions.checkNotNull(tx);
 174
 175         final List<? extends TransactionAware> cacheNotifs = txContainer.get().getNotifications();
 176         for (final TransactionAware notif : cacheNotifs) {
 177             if ( ! (notif instanceof QueueStatisticsUpdate)) {
 178                 break;
 179             }
 180             final List<QueueIdAndStatisticsMap> queueStats = ((QueueStatisticsUpdate) notif).getQueueIdAndStatisticsMap();
 181             if (queueStats == null) {
 182                 break;
 183             }
 184             for (final QueueIdAndStatisticsMap queueStat : queueStats) {
 185                 if (queueStat.getQueueId() != null) {
 186                     final FlowCapableNodeConnectorQueueStatistics statChild =
 187                             new FlowCapableNodeConnectorQueueStatisticsBuilder(queueStat).build();
 188                     final FlowCapableNodeConnectorQueueStatisticsDataBuilder statBuild =
 189                             new FlowCapableNodeConnectorQueueStatisticsDataBuilder();
 190                     statBuild.setFlowCapableNodeConnectorQueueStatistics(statChild);
 191                     final QueueKey qKey = new QueueKey(queueStat.getQueueId());
 192                     final InstanceIdentifier<Queue> queueIdent = nodeIdent
 193                             .child(NodeConnector.class, new NodeConnectorKey(queueStat.getNodeConnectorId()))
 194                             .augmentation(FlowCapableNodeConnector.class)
 195                             .child(Queue.class, qKey);
 196                     final InstanceIdentifier<FlowCapableNodeConnectorQueueStatisticsData> queueStatIdent = queueIdent.augmentation(FlowCapableNodeConnectorQueueStatisticsData.class);
 197                     existQueueKeys.remove(qKey);
 198                     tx.merge(LogicalDatastoreType.OPERATIONAL, queueIdent, new QueueBuilder().setKey(qKey).build());
 199                     tx.put(LogicalDatastoreType.OPERATIONAL, queueStatIdent, statBuild.build());
 200                 }
 201             }
 202         }
 203     }
 204
 205     private void deleteAllNotPresentedNodes(final InstanceIdentifier<Node> nodeIdent,
 206             final ReadWriteTransaction tx, final Map<QueueKey, NodeConnectorKey> existQueueKeys) {
 207
 208         Preconditions.checkNotNull(nodeIdent);
 209         Preconditions.checkNotNull(tx);
 210
 211         if (existQueueKeys == null) {
 212             return;
 213         }
 214
 215         for (final Entry<QueueKey, NodeConnectorKey> entry : existQueueKeys.entrySet()) {
 216             final InstanceIdentifier<Queue> queueIdent = nodeIdent.child(NodeConnector.class, entry.getValue())
 217                     .augmentation(FlowCapableNodeConnector.class).child(Queue.class, entry.getKey());
 218             LOG.trace("Queue {} has to removed.", queueIdent);
 219             Optional<Queue> delQueue = Optional.absent();
 220             try {
 221                 delQueue = tx.read(LogicalDatastoreType.OPERATIONAL, queueIdent).checkedGet();
 222             }
 223             catch (final ReadFailedException e) {
 224                 // NOOP - probably another transaction delete that node
 225                 LOG.debug("Queue {} was probably deleted via another transaction. Exception {}", queueIdent, e);
 226             }
 227             if (delQueue.isPresent()) {
 228                 tx.delete(LogicalDatastoreType.OPERATIONAL, queueIdent);
 229             }
 230         }
 231     }
 232 }
 233