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