opendaylight/md-sal/statistics-manager/src/main/java/org/opendaylight/controller/md/statistics/manager/impl/StatNodeRegistrationImpl.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.controller.md.statistics.manager.impl;
  10
  11 import java.util.ArrayList;
  12 import java.util.Collections;
  13 import java.util.List;
  14 import java.util.Set;
  15
  16 import org.opendaylight.controller.md.sal.binding.api.DataBroker;
  17 import org.opendaylight.controller.md.sal.binding.api.DataChangeListener;
  18 import org.opendaylight.controller.md.sal.binding.api.ReadWriteTransaction;
  19 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataBroker.DataChangeScope;
  20 import org.opendaylight.controller.md.sal.common.api.data.AsyncDataChangeEvent;
  21 import org.opendaylight.controller.md.sal.common.api.data.LogicalDatastoreType;
  22 import org.opendaylight.controller.md.statistics.manager.StatNodeRegistration;
  23 import org.opendaylight.controller.md.statistics.manager.StatPermCollector.StatCapabTypes;
  24 import org.opendaylight.controller.md.statistics.manager.StatisticsManager;
  25 import org.opendaylight.controller.md.statistics.manager.StatisticsManager.StatDataStoreOperation;
  26 import org.opendaylight.controller.md.statistics.manager.StatisticsManager.StatDataStoreOperation.StatsManagerOperationType;
  27 import org.opendaylight.controller.sal.binding.api.NotificationProviderService;
  28 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FeatureCapability;
  29 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNode;
  30 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowCapableNodeUpdated;
  31 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityFlowStats;
  32 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityGroupStats;
  33 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityPortStats;
  34 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityQueueStats;
  35 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.FlowFeatureCapabilityTableStats;
  36 import org.opendaylight.yang.gen.v1.urn.opendaylight.flow.inventory.rev130819.flow.node.SwitchFeatures;
  37 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorRemoved;
  38 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeConnectorUpdated;
  39 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRef;
  40 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeRemoved;
  41 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.NodeUpdated;
  42 import org.opendaylight.yang.gen.v1.urn.opendaylight.inventory.rev130819.Nodes;
  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.yangtools.concepts.ListenerRegistration;
  46 import org.opendaylight.yangtools.yang.binding.DataObject;
  47 import org.opendaylight.yangtools.yang.binding.InstanceIdentifier;
  48 import org.slf4j.Logger;
  49 import org.slf4j.LoggerFactory;
  50
  51 import com.google.common.base.Optional;
  52 import com.google.common.base.Preconditions;
  53
  54 /**
  55  * statistics-manager
  56  * org.opendaylight.controller.md.statistics.manager.impl
  57  *
  58  * StatNodeRegistrationImpl
  59  * {@link FlowCapableNode} Registration Implementation contains two method for registration/unregistration
  60  * {@link FeatureCapability} for every connect/disconnect {@link FlowCapableNode}. Process of connection/disconnection
  61  * is substituted by listening Operation/DS for add/delete {@link FeatureCapability}.
  62  * All statistic capabilities are reading from new Node directly without contacting device or DS.
  63  *
  64  * @author <a href="mailto:vdemcak@cisco.com">Vaclav Demcak</a>
  65  *
  66  * Created: Aug 28, 2014
  67  */
  68 public class StatNodeRegistrationImpl implements StatNodeRegistration, DataChangeListener {
  69
  70     private static final Logger LOG = LoggerFactory.getLogger(StatNodeRegistrationImpl.class);
  71
  72     private final StatisticsManager manager;
  73     private ListenerRegistration<DataChangeListener> listenerRegistration;
  74     private ListenerRegistration<?> notifListenerRegistration;
  75
  76     public StatNodeRegistrationImpl(final StatisticsManager manager, final DataBroker db,
  77             final NotificationProviderService notificationService) {
  78         this.manager = Preconditions.checkNotNull(manager, "StatisticManager can not be null!");
  79         Preconditions.checkArgument(db != null, "DataBroker can not be null!");
  80         Preconditions.checkArgument(notificationService != null, "NotificationProviderService can not be null!");
  81         notifListenerRegistration = notificationService.registerNotificationListener(this);
  82         /* Build Path */
  83         final InstanceIdentifier<FlowCapableNode> flowNodeWildCardIdentifier = InstanceIdentifier.create(Nodes.class)
  84                 .child(Node.class).augmentation(FlowCapableNode.class);
  85         listenerRegistration = db.registerDataChangeListener(LogicalDatastoreType.OPERATIONAL,
  86                 flowNodeWildCardIdentifier, StatNodeRegistrationImpl.this, DataChangeScope.BASE);
  87     }
  88
  89     @Override
  90     public void close() throws Exception {
  91
  92         if (notifListenerRegistration != null) {
  93             try {
  94                 notifListenerRegistration.close();
  95             }
  96             catch (final Exception e) {
  97                 LOG.warn("Error by stop FlowCapableNode Notification StatNodeRegistration.");
  98             }
  99             notifListenerRegistration = null;
 100         }
 101
 102         if (listenerRegistration != null) {
 103             try {
 104                 listenerRegistration.close();
 105             } catch (final Exception e) {
 106                 LOG.warn("Error by stop FlowCapableNode DataChange StatListeningCommiter.", e);
 107             }
 108             listenerRegistration = null;
 109         }
 110     }
 111
 112     @Override
 113     public void connectFlowCapableNode(final InstanceIdentifier<SwitchFeatures> keyIdent,
 114             final SwitchFeatures data, final InstanceIdentifier<Node> nodeIdent) {
 115         Preconditions.checkNotNull(keyIdent, "InstanceIdentifier can not be null!");
 116         Preconditions.checkNotNull(data, "SwitchFeatures data for {} can not be null!", keyIdent);
 117         Preconditions.checkArgument(( ! keyIdent.isWildcarded()), "InstanceIdentifier is WildCarded!");
 118
 119         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.NODE_UPDATE,nodeIdent.firstKeyOf(Node.class, NodeKey.class).getId()) {
 120
 121             @Override
 122             public void applyOperation(final ReadWriteTransaction tx) {
 123
 124                 final List<StatCapabTypes> statCapabTypes = new ArrayList<>();
 125                 Short maxCapTables = Short.valueOf("1");
 126
 127                 final List<Class<? extends FeatureCapability>> capabilities = data.getCapabilities() != null
 128                         ? data.getCapabilities() : Collections.<Class<? extends FeatureCapability>> emptyList();
 129                 for (final Class<? extends FeatureCapability> capability : capabilities) {
 130                     if (capability == FlowFeatureCapabilityTableStats.class) {
 131                         statCapabTypes.add(StatCapabTypes.TABLE_STATS);
 132                     } else if (capability == FlowFeatureCapabilityFlowStats.class) {
 133                         statCapabTypes.add(StatCapabTypes.FLOW_STATS);
 134                     } else if (capability == FlowFeatureCapabilityGroupStats.class) {
 135                         statCapabTypes.add(StatCapabTypes.GROUP_STATS);
 136                     } else if (capability == FlowFeatureCapabilityPortStats.class) {
 137                         statCapabTypes.add(StatCapabTypes.PORT_STATS);
 138                     } else if (capability == FlowFeatureCapabilityQueueStats.class) {
 139                         statCapabTypes.add(StatCapabTypes.QUEUE_STATS);
 140                     }
 141                 }
 142                 maxCapTables = data.getMaxTables();
 143
 144                 final Optional<Short> maxTables = Optional.<Short> of(maxCapTables);
 145                 manager.connectedNodeRegistration(nodeIdent,
 146                         Collections.unmodifiableList(statCapabTypes), maxTables.get());
 147             }
 148         });
 149     }
 150
 151     @Override
 152     public void disconnectFlowCapableNode(final InstanceIdentifier<Node> nodeIdent) {
 153         Preconditions.checkArgument(nodeIdent != null, "InstanceIdentifier can not be NULL!");
 154         Preconditions.checkArgument(( ! nodeIdent.isWildcarded()),
 155                 "InstanceIdentifier {} is WildCarded!", nodeIdent);
 156         manager.enqueue(new StatDataStoreOperation(StatsManagerOperationType.NODE_REMOVAL,nodeIdent.firstKeyOf(Node.class, NodeKey.class).getId()) {
 157
 158             @Override
 159             public void applyOperation(final ReadWriteTransaction tx) {
 160                 manager.disconnectedNodeUnregistration(nodeIdent);
 161             }
 162         });
 163     }
 164
 165
 166     @Override
 167     public void onNodeConnectorRemoved(final NodeConnectorRemoved notification) {
 168         // NOOP
 169     }
 170
 171     @Override
 172     public void onNodeConnectorUpdated(final NodeConnectorUpdated notification) {
 173         // NOOP
 174     }
 175
 176     @Override
 177     public void onNodeRemoved(final NodeRemoved notification) {
 178         Preconditions.checkNotNull(notification);
 179         final NodeRef nodeRef = notification.getNodeRef();
 180         final InstanceIdentifier<?> nodeRefIdent = nodeRef.getValue();
 181         final InstanceIdentifier<Node> nodeIdent =
 182                 nodeRefIdent.firstIdentifierOf(Node.class);
 183         if (nodeIdent != null) {
 184             disconnectFlowCapableNode(nodeIdent);
 185         }
 186     }
 187
 188     @Override
 189     public void onNodeUpdated(final NodeUpdated notification) {
 190         Preconditions.checkNotNull(notification);
 191         final FlowCapableNodeUpdated newFlowNode =
 192                 notification.getAugmentation(FlowCapableNodeUpdated.class);
 193         if (newFlowNode != null && newFlowNode.getSwitchFeatures() != null) {
 194             final NodeRef nodeRef = notification.getNodeRef();
 195             final InstanceIdentifier<?> nodeRefIdent = nodeRef.getValue();
 196             final InstanceIdentifier<Node> nodeIdent =
 197                     nodeRefIdent.firstIdentifierOf(Node.class);
 198
 199             final InstanceIdentifier<SwitchFeatures> swichFeaturesIdent =
 200                     nodeIdent.augmentation(FlowCapableNode.class).child(SwitchFeatures.class);
 201             final SwitchFeatures switchFeatures = newFlowNode.getSwitchFeatures();
 202             connectFlowCapableNode(swichFeaturesIdent, switchFeatures, nodeIdent);
 203         }
 204     }
 205
 206     @Override
 207     public void onDataChanged(final AsyncDataChangeEvent<InstanceIdentifier<?>, DataObject> changeEvent) {
 208         Preconditions.checkNotNull(changeEvent,"Async ChangeEvent can not be null!");
 209         /* All DataObjects for create */
 210         final Set<InstanceIdentifier<?>>  createdData = changeEvent.getCreatedData() != null
 211                 ? changeEvent.getCreatedData().keySet() : Collections.<InstanceIdentifier<?>> emptySet();
 212
 213         for (final InstanceIdentifier<?> entryKey : createdData) {
 214             final InstanceIdentifier<Node> nodeIdent = entryKey
 215                     .firstIdentifierOf(Node.class);
 216             if ( ! nodeIdent.isWildcarded()) {
 217                 final NodeRef nodeRef = new NodeRef(nodeIdent);
 218                 // FIXME: these calls is a job for handshake or for inventory manager
 219                 /* check Group and Meter future */
 220                 manager.getRpcMsgManager().getGroupFeaturesStat(nodeRef);
 221                 manager.getRpcMsgManager().getMeterFeaturesStat(nodeRef);
 222             }
 223         }
 224     }
 225 }
 226