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.Collections;
12 import java.util.Date;
13 import java.util.Dictionary;
14 import java.util.HashMap;
15 import java.util.HashSet;
18 import java.util.concurrent.ConcurrentHashMap;
19 import java.util.concurrent.ConcurrentMap;
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.ConstructionException;
27 import org.opendaylight.controller.sal.core.Node;
28 import org.opendaylight.controller.sal.core.Node.NodeIDType;
29 import org.opendaylight.controller.sal.core.NodeConnector;
30 import org.opendaylight.controller.sal.core.Property;
31 import org.opendaylight.controller.sal.core.UpdateType;
32 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
33 import org.opendaylight.controller.sal.inventory.IPluginOutInventoryService;
34 import org.opendaylight.controller.sal.utils.GlobalConstants;
35 import org.slf4j.Logger;
36 import org.slf4j.LoggerFactory;
39 * The class describes inventory service protocol plugin. One instance per
40 * container of the network. Each instance gets container specific inventory
41 * events from InventoryServiceShim. It interacts with SAL to pass inventory
42 * data to the upper application.
46 public class InventoryService implements IInventoryShimInternalListener,
47 IPluginInInventoryService, IInventoryProvider {
48 protected static final Logger logger = LoggerFactory
49 .getLogger(InventoryService.class);
50 private Set<IPluginOutInventoryService> pluginOutInventoryServices = Collections
51 .synchronizedSet(new HashSet<IPluginOutInventoryService>());
52 private IController controller = null;
53 private ConcurrentMap<Node, Map<String, Property>> nodeProps; // properties are maintained in global container only
54 private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps; // properties are maintained in global container only
55 private boolean isDefaultContainer = false;
57 void setController(IController s) {
61 void unsetController(IController s) {
62 if (this.controller == s) {
63 this.controller = null;
68 * Function called by the dependency manager when all the required
69 * dependencies are satisfied
72 @SuppressWarnings("rawtypes")
73 void init(Component c) {
74 logger.trace("INIT called!");
76 Dictionary props = c.getServiceProperties();
78 String containerName = (String) props.get("containerName");
79 isDefaultContainer = containerName.equals(GlobalConstants.DEFAULT
83 nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
84 nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
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.
94 logger.trace("DESTROY called!");
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
103 logger.trace("START called!");
107 * Function called by the dependency manager before the services exported by
108 * the component are unregistered, this will be followed by a "destroy ()"
113 logger.trace("STOP called!");
116 public void setPluginOutInventoryServices(IPluginOutInventoryService service) {
117 logger.trace("Got a service set request {}", service);
118 if (this.pluginOutInventoryServices != null) {
119 this.pluginOutInventoryServices.add(service);
123 public void unsetPluginOutInventoryServices(
124 IPluginOutInventoryService service) {
125 logger.trace("Got a service UNset request");
126 if (this.pluginOutInventoryServices != null) {
127 this.pluginOutInventoryServices.remove(service);
131 protected Node OFSwitchToNode(ISwitch sw) {
133 Object id = sw.getId();
136 node = new Node(NodeIDType.OPENFLOW, id);
137 } catch (ConstructionException e) {
145 * Retrieve nodes from openflow
148 public ConcurrentMap<Node, Map<String, Property>> getNodeProps() {
153 public ConcurrentMap<NodeConnector, Map<String, Property>> getNodeConnectorProps(
155 if (nodeConnectorProps == null) {
159 if (isDefaultContainer && refresh) {
160 Map<Long, ISwitch> switches = controller.getSwitches();
161 for (ISwitch sw : switches.values()) {
162 Map<NodeConnector, Set<Property>> ncProps = InventoryServiceHelper
163 .OFSwitchToProps(sw);
164 for (Map.Entry<NodeConnector, Set<Property>> entry : ncProps
166 updateNodeConnector(entry.getKey(), UpdateType.ADDED,
172 return nodeConnectorProps;
176 public void updateNodeConnector(NodeConnector nodeConnector,
177 UpdateType type, Set<Property> props) {
178 logger.trace("updateNodeConnector {} type {}", nodeConnector,
180 if (nodeConnectorProps == null) {
181 logger.trace("nodeConnectorProps is null");
185 Map<String, Property> propMap = nodeConnectorProps.get(nodeConnector);
189 if (propMap == null) {
190 propMap = new HashMap<String, Property>();
193 for (Property prop : props) {
194 propMap.put(prop.getName(), prop);
197 nodeConnectorProps.put(nodeConnector, propMap);
200 nodeConnectorProps.remove(nodeConnector);
206 // update sal and discovery
207 synchronized (pluginOutInventoryServices) {
208 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
209 service.updateNodeConnector(nodeConnector, type, props);
214 private void addNode(Node node, Set<Property> props) {
215 logger.trace("{} added, props: {}", node, props);
216 if (nodeProps == null) {
220 // update local cache
221 Map<String, Property> propMap = new HashMap<String, Property>();
222 for (Property prop : props) {
223 propMap.put(prop.getName(), prop);
225 nodeProps.put(node, propMap);
228 synchronized (pluginOutInventoryServices) {
229 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
230 service.updateNode(node, UpdateType.ADDED, props);
235 private void removeNode(Node node) {
236 logger.trace("{} removed", node);
237 if (nodeProps == null)
240 // update local cache
241 nodeProps.remove(node);
243 Set<NodeConnector> removeSet = new HashSet<NodeConnector>();
244 for (NodeConnector nodeConnector : nodeConnectorProps.keySet()) {
245 if (nodeConnector.getNode().equals(node)) {
246 removeSet.add(nodeConnector);
249 for (NodeConnector nodeConnector : removeSet) {
250 nodeConnectorProps.remove(nodeConnector);
254 synchronized (pluginOutInventoryServices) {
255 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
256 service.updateNode(node, UpdateType.REMOVED, null);
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()) {
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);
280 // Update SAL if we got new properties
281 if (!newProperties.isEmpty()) {
282 synchronized (pluginOutInventoryServices) {
283 for (IPluginOutInventoryService service : pluginOutInventoryServices) {
284 service.updateNode(node, UpdateType.CHANGED, newProperties);
291 public void updateNode(Node node, UpdateType type, Set<Property> props) {
294 addNode(node, props);
300 updateNode(node, props);