opendaylight/adsal/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.Collections;
  12 import java.util.Dictionary;
  13 import java.util.HashMap;
  14 import java.util.HashSet;
  15 import java.util.Map;
  16 import java.util.Set;
  17 import java.util.concurrent.ConcurrentHashMap;
  18 import java.util.concurrent.ConcurrentMap;
  19 import java.util.concurrent.CopyOnWriteArraySet;
  20
  21 import org.apache.felix.dm.Component;
  22 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryProvider;
  23 import org.opendaylight.controller.protocol_plugin.openflow.IInventoryShimInternalListener;
  24 import org.opendaylight.controller.protocol_plugin.openflow.core.IController;
  25 import org.opendaylight.controller.protocol_plugin.openflow.core.ISwitch;
  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 final Set<IPluginOutInventoryService> pluginOutInventoryServices =
  49             new CopyOnWriteArraySet<IPluginOutInventoryService>();
  50     private IController controller = null;
  51     private ConcurrentMap<Node, Map<String, Property>> nodeProps;
  52     private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps;
  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     // nothing to return
 143     @Override
 144     public Set<Node> getConfiguredNotConnectedNodes() {
 145         return Collections.emptySet();
 146     }
 147
 148     @Override
 149     public ConcurrentMap<NodeConnector, Map<String, Property>> getNodeConnectorProps(
 150             Boolean refresh) {
 151         if (nodeConnectorProps == null) {
 152             return null;
 153         }
 154
 155         if (isDefaultContainer && refresh) {
 156             Map<Long, ISwitch> switches = controller.getSwitches();
 157             for (ISwitch sw : switches.values()) {
 158                 Map<NodeConnector, Set<Property>> ncProps = InventoryServiceHelper
 159                         .OFSwitchToProps(sw);
 160                 for (Map.Entry<NodeConnector, Set<Property>> entry : ncProps
 161                         .entrySet()) {
 162                     updateNodeConnector(entry.getKey(), UpdateType.ADDED,
 163                             entry.getValue());
 164                 }
 165             }
 166         }
 167
 168         return nodeConnectorProps;
 169     }
 170
 171     @Override
 172     public void updateNodeConnector(NodeConnector nodeConnector,
 173             UpdateType type, Set<Property> props) {
 174         logger.trace("updateNodeConnector {} type {}", nodeConnector,
 175                 type.getName());
 176         if (nodeConnectorProps == null) {
 177             logger.trace("nodeConnectorProps is null");
 178             return;
 179         }
 180
 181         Map<String, Property> propMap = nodeConnectorProps.get(nodeConnector);
 182         switch (type) {
 183         case ADDED:
 184         case CHANGED:
 185             if (propMap == null) {
 186                 propMap = new HashMap<String, Property>();
 187             }
 188             if (props != null) {
 189                 for (Property prop : props) {
 190                     propMap.put(prop.getName(), prop);
 191                 }
 192             }
 193             nodeConnectorProps.put(nodeConnector, propMap);
 194             break;
 195         case REMOVED:
 196             nodeConnectorProps.remove(nodeConnector);
 197             break;
 198         default:
 199             return;
 200         }
 201
 202         // update sal and discovery
 203         for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 204             service.updateNodeConnector(nodeConnector, type, props);
 205         }
 206
 207     }
 208
 209     private void addNode(Node node, Set<Property> props) {
 210         if (nodeProps == null) {
 211             return;
 212         }
 213
 214         logger.trace("addNode: {} added, props: {} for container {}",
 215                 new Object[] { node, props, containerName });
 216
 217         // update local cache
 218         Map<String, Property> propMap = nodeProps.get(node);
 219         if (propMap == null) {
 220             propMap = new HashMap<String, Property>();
 221         }
 222
 223         if (props != null) {
 224             for (Property prop : props) {
 225                 propMap.put(prop.getName(), prop);
 226             }
 227         }
 228         nodeProps.put(node, propMap);
 229
 230         // update sal
 231         for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 232             service.updateNode(node, UpdateType.ADDED, props);
 233         }
 234     }
 235
 236     private void removeNode(Node node) {
 237         logger.trace("{} removed", node);
 238         if (nodeProps == null) {
 239             return;
 240         }
 241
 242         // update local cache
 243         nodeProps.remove(node);
 244
 245         Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
 246         for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
 247             if (nodeConnector.getNode().equals(node)) {
 248                 removeSet.add(nodeConnector);
 249             }
 250         }
 251         for (NodeConnector nodeConnector : removeSet) {
 252             nodeConnectorProps.remove(nodeConnector);
 253         }
 254
 255         // update sal
 256         for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 257             service.updateNode(node, UpdateType.REMOVED, null);
 258         }
 259     }
 260
 261     private void updateNode(Node node, Set<Property> properties) {
 262         logger.trace("{} updated, props: {}", node, properties);
 263         if ((nodeProps == null) || !nodeProps.containsKey(node) ||
 264                 (properties == null) || properties.isEmpty()) {
 265             return;
 266         }
 267
 268         // Update local cache with new properties
 269         Set<Property> newProperties = new HashSet<Property>(properties.size());
 270         Map<String, Property> propertyMap = nodeProps.get(node);
 271         for (Property property : properties) {
 272             String name = property.getName();
 273             Property currentProperty = propertyMap.get(name);
 274             if (!property.equals(currentProperty)) {
 275                 propertyMap.put(name, property);
 276                 newProperties.add(property);
 277             }
 278         }
 279
 280         // Update SAL if we got new properties
 281         if (!newProperties.isEmpty()) {
 282             for (IPluginOutInventoryService service : pluginOutInventoryServices) {
 283                 service.updateNode(node, UpdateType.CHANGED, newProperties);
 284             }
 285         }
 286     }
 287
 288     @Override
 289     public void updateNode(Node node, UpdateType type, Set<Property> props) {
 290         switch (type) {
 291         case ADDED:
 292             addNode(node, props);
 293             break;
 294         case REMOVED:
 295             removeNode(node);
 296             break;
 297         case CHANGED:
 298             updateNode(node, props);
 299             break;
 300         default:
 301             break;
 302         }
 303     }
 304 }