opendaylight/protocol_plugins/openflow/src/main/java/org/opendaylight/controller/protocol_plugin/openflow/internal/InventoryService.java

   1 /*
   2  * Copyright (c) 2013 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.protocol_plugin.openflow.internal;
  10
  11 import java.util.Dictionary;
  12 import java.util.HashMap;
  13 import java.util.HashSet;
  14 import java.util.Map;
  15 import java.util.Set;
  16 import java.util.concurrent.ConcurrentHashMap;
  17 import java.util.concurrent.ConcurrentMap;
  18 import java.util.concurrent.CopyOnWriteArraySet;
  19
  20 import org.apache.felix.dm.Component;
  21 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryProvider;
  22 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimInternalListener;
  23 import org.opendaylight.controller.protocol_plugin.openflow.core.IController;
  24 import org.opendaylight.controller.protocol_plugin.openflow.core.ISwitch;
  25 import org.opendaylight.controller.sal.connection.IPluginOutConnectionService;
  26 import org.opendaylight.controller.sal.core.Node;
  27 import org.opendaylight.controller.sal.core.NodeConnector;
  28 import org.opendaylight.controller.sal.core.Property;
  29 import org.opendaylight.controller.sal.core.UpdateType;
  30 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
  31 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService;
  32 import org.opendaylight.controller.sal.utils.GlobalConstants;
  33 import org.slf4j.Logger;
  34 import org.slf4j.LoggerFactory;
  35
  36 /**
  37  * The class describes inventory service protocol plugin. One instance per
  38  * container of the network. Each instance gets container specific inventory
  39  * events from InventoryServiceShim. It interacts with SAL to pass inventory
  40  * data to the upper application.
  41  *
  42  *
  43  */
  44 public class InventoryService implements IInventoryShimInternalListener,
  45         IPluginInInventoryService, IInventoryProvider {
  46     protected static final Logger logger = LoggerFactory
  47             .getLogger(InventoryService.class);
  48     private Set<IPluginOutInventoryService> pluginOutInventoryServices =
  49             new CopyOnWriteArraySet<IPluginOutInventoryService>();
  50     private IController controller = null;
  51     private ConcurrentMap<Node, Map<String, Property>> nodeProps; // properties are maintained in global container only
  52     private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps; // properties are maintained in global container only
  53     private boolean isDefaultContainer = false;
  54     private String containerName = null;
  55
  56     void setController(IController s) {
  57         this.controller = s;
  58     }
  59
  60     void unsetController(IController s) {
  61         if (this.controller == s) {
  62             this.controller = null;
  63         }
  64     }
  65
  66     /**
  67      * Function called by the dependency manager when all the required
  68      * dependencies are satisfied
  69      *
  70      */
  71     @SuppressWarnings("rawtypes")
  72     void init(Component c) {
  73         logger.trace("INIT called!");
  74
  75         Dictionary props = c.getServiceProperties();
  76         if (props != null) {
  77             containerName = (String) props.get("containerName");
  78             if (containerName != null) {
  79                 isDefaultContainer = containerName.equals(GlobalConstants.DEFAULT
  80                         .toString());
  81             }
  82         }
  83
  84         nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
  85         nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
  86     }
  87
  88     /**
  89      * Function called by the dependency manager when at least one dependency
  90      * become unsatisfied or when the component is shutting down because for
  91      * example bundle is being stopped.
  92      *
  93      */
  94     void destroy() {
  95         logger.trace("DESTROY called!");
  96     }
  97
  98     /**
  99      * Function called by dependency manager after "init ()" is called and after
 100      * the services provided by the class are registered in the service registry
 101      *
 102      */
 103     void start() {
 104         logger.trace("START called!");
 105     }
 106
 107     /**
 108      * Function called by the dependency manager before the services exported by
 109      * the component are unregistered, this will be followed by a "destroy ()"
 110      * calls
 111      *
 112      */
 113     void stop() {
 114         logger.trace("STOP called!");
 115         pluginOutInventoryServices.clear();
 116     }
 117
 118     public void setPluginOutInventoryServices(IPluginOutInventoryService service) {
 119         logger.trace("Got a service set request {}", service);
 120         if (this.pluginOutInventoryServices != null) {
 121             this.pluginOutInventoryServices.add(service);
 122         }
 123     }
 124
 125     public void unsetPluginOutInventoryServices(
 126             IPluginOutInventoryService service) {
 127         logger.trace("Got a service UNset request");
 128         if (this.pluginOutInventoryServices != null) {
 129             this.pluginOutInventoryServices.remove(service);
 130         }
 131     }
 132
 133     /**
 134      * Retrieve nodes from openflow
 135      */
 136     @Override
 137     public ConcurrentMap<Node, Map<String, Property>> getNodeProps() {
 138         logger.debug("getNodePros for container {}", containerName);
 139         return nodeProps;
 140     }
 141
 142     @Override
 143     public ConcurrentMap<NodeConnector, Map<String, Property>> getNodeConnectorProps(
 144             Boolean refresh) {
 145         if (nodeConnectorProps == null) {
 146             return null;
 147         }
 148
 149         if (isDefaultContainer && refresh) {
 150             Map<Long, ISwitch> switches = controller.getSwitches();
 151             for (ISwitch sw : switches.values()) {
 152                 Map<NodeConnector, Set<Property>> ncProps = InventoryServiceHelper
 153                         .OFSwitchToProps(sw);
 154                 for (Map.Entry<NodeConnector, Set<Property>> entry : ncProps
 155                         .entrySet()) {
 156                     updateNodeConnector(entry.getKey(), UpdateType.ADDED,
 157                             entry.getValue());
 158                 }
 159             }
 160         }
 161
 162         return nodeConnectorProps;
 163     }
 164
 165     @Override
 166     public void updateNodeConnector(NodeConnector nodeConnector,
 167             UpdateType type, Set<Property> props) {
 168         logger.trace("updateNodeConnector {} type {}", nodeConnector,
 169                 type.getName());
 170         if (nodeConnectorProps == null) {
 171             logger.trace("nodeConnectorProps is null");
 172             return;
 173         }
 174
 175         Map<String, Property> propMap = nodeConnectorProps.get(nodeConnector);
 176         switch (type) {
 177         case ADDED:
 178         case CHANGED:
 179             if (propMap == null) {
 180                 propMap = new HashMap<String, Property>();
 181             }
 182             if (props != null) {
 183                 for (Property prop : props) {
 184                     propMap.put(prop.getName(), prop);
 185                 }
 186             }
 187             nodeConnectorProps.put(nodeConnector, propMap);
 188             break;
 189         case REMOVED:
 190             nodeConnectorProps.remove(nodeConnector);
 191             break;
 192         default:
 193             return;
 194         }
 195
 196         // update sal and discovery
 197         for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 198             service.updateNodeConnector(nodeConnector, type, props);
 199         }
 200
 201     }
 202
 203     private void addNode(Node node, Set<Property> props) {
 204         if (nodeProps == null) {
 205             return;
 206         }
 207
 208         logger.trace("addNode: {} added, props: {} for container {}",
 209                 new Object[] { node, props, containerName });
 210
 211         // update local cache
 212         Map<String, Property> propMap = nodeProps.get(node);
 213         if (propMap == null) {
 214             propMap = new HashMap<String, Property>();
 215         }
 216
 217         if (props != null) {
 218             for (Property prop : props) {
 219                 propMap.put(prop.getName(), prop);
 220             }
 221         }
 222         nodeProps.put(node, propMap);
 223
 224         // update sal
 225         for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 226             service.updateNode(node, UpdateType.ADDED, props);
 227         }
 228     }
 229
 230     private void removeNode(Node node) {
 231         logger.trace("{} removed", node);
 232         if (nodeProps == null) {
 233             return;
 234         }
 235
 236         // update local cache
 237         nodeProps.remove(node);
 238
 239         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 240         for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
 241             if (nodeConnector.getNode().equals(node)) {
 242                 removeSet.add(nodeConnector);
 243             }
 244         }
 245         for (NodeConnector nodeConnector : removeSet) {
 246             nodeConnectorProps.remove(nodeConnector);
 247         }
 248
 249         // update sal
 250         for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 251             service.updateNode(node, UpdateType.REMOVED, null);
 252         }
 253     }
 254
 255     private void updateNode(Node node, Set<Property> properties) {
 256         logger.trace("{} updated, props: {}", node, properties);
 257         if ((nodeProps == null) || !nodeProps.containsKey(node) ||
 258                 (properties == null) || properties.isEmpty()) {
 259             return;
 260         }
 261
 262         // Update local cache with new properties
 263         Set<Property> newProperties = new HashSet<Property>(properties.size());
 264         Map<String, Property> propertyMap = nodeProps.get(node);
 265         for (Property property : properties) {
 266             String name = property.getName();
 267             Property currentProperty = propertyMap.get(name);
 268             if (!property.equals(currentProperty)) {
 269                 propertyMap.put(name, property);
 270                 newProperties.add(property);
 271             }
 272         }
 273
 274         // Update SAL if we got new properties
 275         if (!newProperties.isEmpty()) {
 276             for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 277                 service.updateNode(node, UpdateType.CHANGED, newProperties);
 278             }
 279         }
 280     }
 281
 282     @Override
 283     public void updateNode(Node node, UpdateType type, Set<Property> props) {
 284         switch (type) {
 285         case ADDED:
 286             addNode(node, props);
 287             break;
 288         case REMOVED:
 289             removeNode(node);
 290             break;
 291         case CHANGED:
 292             updateNode(node, props);
 293             break;
 294         default:
 295             break;
 296         }
 297     }
 298 }