2 * Copyright (c) 2013 Cisco Systems, Inc. and others. All rights reserved.
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
9 package org.opendaylight.controller.protocol_plugin.openflow.internal;
11 import java.util.Dictionary;
12 import java.util.HashMap;
13 import java.util.HashSet;
16 import java.util.concurrent.ConcurrentHashMap;
17 import java.util.concurrent.ConcurrentMap;
18 import java.util.concurrent.CopyOnWriteArraySet;
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;
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.
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;
54 void setController(IController s) {
58 void unsetController(IController s) {
59 if (this.controller == s) {
60 this.controller = null;
65 * Function called by the dependency manager when all the required
66 * dependencies are satisfied
69 @SuppressWarnings("rawtypes")
70 void init(Component c) {
71 logger.trace("INIT called!");
73 Dictionary props = c.getServiceProperties();
75 containerName = (String) props.get("containerName");
76 isDefaultContainer = containerName.equals(GlobalConstants.DEFAULT
80 nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
81 nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
82 pluginOutInventoryServices = new CopyOnWriteArraySet<IPluginOutInventoryService>();
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.
92 logger.trace("DESTROY called!");
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
101 logger.trace("START called!");
105 * Function called by the dependency manager before the services exported by
106 * the component are unregistered, this will be followed by a "destroy ()"
111 logger.trace("STOP called!");
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);
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);
130 * Retrieve nodes from openflow
133 public ConcurrentMap<Node, Map<String, Property>> getNodeProps() {
134 logger.debug("getNodePros for container {}", containerName);
139 public ConcurrentMap<NodeConnector, Map<String, Property>> getNodeConnectorProps(
141 if (nodeConnectorProps == null) {
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
152 updateNodeConnector(entry.getKey(), UpdateType.ADDED,
158 return nodeConnectorProps;
162 public void updateNodeConnector(NodeConnector nodeConnector,
163 UpdateType type, Set<Property> props) {
164 logger.trace("updateNodeConnector {} type {}", nodeConnector,
166 if (nodeConnectorProps == null) {
167 logger.trace("nodeConnectorProps is null");
171 Map<String, Property> propMap = nodeConnectorProps.get(nodeConnector);
175 if (propMap == null) {
176 propMap = new HashMap<String, Property>();
179 for (Property prop : props) {
180 propMap.put(prop.getName(), prop);
183 nodeConnectorProps.put(nodeConnector, propMap);
186 nodeConnectorProps.remove(nodeConnector);
192 // update sal and discovery
193 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
194 service.updateNodeConnector(nodeConnector, type, props);
199 private void addNode(Node node, Set<Property> props) {
200 if (nodeProps == null) {
204 Set<Node> nodeSet = nodeProps.keySet();
205 if (((props == null) || props.isEmpty()) && (nodeSet != null)
206 && nodeSet.contains(node)) {
207 // node already added
211 logger.trace("addNode: {} added, props: {} for container {}",
212 new Object[] { node, props, containerName });
214 // update local cache
215 Map<String, Property> propMap = nodeProps.get(node);
216 if (propMap == null) {
217 propMap = new HashMap<String, Property>();
221 for (Property prop : props) {
222 propMap.put(prop.getName(), prop);
225 nodeProps.put(node, propMap);
228 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
229 service.updateNode(node, UpdateType.ADDED, props);
233 private void removeNode(Node node) {
234 logger.trace("{} removed", node);
235 if (nodeProps == null)
238 // update local cache
239 nodeProps.remove(node);
241 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
242 for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
243 if (nodeConnector.getNode().equals(node)) {
244 removeSet.add(nodeConnector);
247 for (NodeConnector nodeConnector : removeSet) {
248 nodeConnectorProps.remove(nodeConnector);
252 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
253 service.updateNode(node, UpdateType.REMOVED, null);
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()) {
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);
276 // Update SAL if we got new properties
277 if (!newProperties.isEmpty()) {
278 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
279 service.updateNode(node, UpdateType.CHANGED, newProperties);
285 public void updateNode(Node node, UpdateType type, Set<Property> props) {
288 addNode(node, props);
294 updateNode(node, props);