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