ovsdb/src/main/java/org/opendaylight/ovsdb/plugin/InventoryService.java

   1 package org.opendaylight.ovsdb.plugin;
   2
   3 import java.util.Collection;
   4 import java.util.HashMap;
   5 import java.util.Map;
   6 import java.util.Set;
   7 import java.util.concurrent.ConcurrentHashMap;
   8 import java.util.concurrent.ConcurrentMap;
   9
  10 import org.slf4j.Logger;
  11 import org.slf4j.LoggerFactory;
  12 import org.opendaylight.controller.sal.core.Node;
  13 import org.opendaylight.controller.sal.core.NodeConnector;
  14 import org.opendaylight.controller.sal.core.Property;
  15 import org.opendaylight.controller.sal.inventory.IPluginInInventoryService;
  16 import org.opendaylight.ovsdb.lib.database.DatabaseSchema;
  17 import org.opendaylight.ovsdb.lib.message.TableUpdate;
  18 import org.opendaylight.ovsdb.lib.message.TableUpdate.Row;
  19 import org.opendaylight.ovsdb.lib.message.TableUpdates;
  20 import org.opendaylight.ovsdb.lib.table.internal.Table;
  21
  22 import com.google.common.collect.Maps;
  23
  24 /**
  25  * Stub Implementation for IPluginInReadService used by SAL
  26  *
  27  *
  28  */
  29 public class InventoryService implements IPluginInInventoryService, InventoryServiceInternal {
  30     private static final Logger logger = LoggerFactory
  31             .getLogger(InventoryService.class);
  32
  33     private ConcurrentMap<Node, Map<String, Property>> nodeProps;
  34     private ConcurrentMap<NodeConnector, Map<String, Property>> nodeConnectorProps;
  35     private Map<Node, NodeDB> dbCache = Maps.newHashMap();
  36
  37     /**
  38      * Function called by the dependency manager when all the required
  39      * dependencies are satisfied
  40      *
  41      */
  42     public void init() {
  43         nodeProps = new ConcurrentHashMap<Node, Map<String, Property>>();
  44         nodeConnectorProps = new ConcurrentHashMap<NodeConnector, Map<String, Property>>();
  45         Node.NodeIDType.registerIDType("OVS", String.class);
  46         NodeConnector.NodeConnectorIDType.registerIDType("OVS", String.class, "OVS");
  47     }
  48
  49     /**
  50      * Function called by the dependency manager when at least one dependency
  51      * become unsatisfied or when the component is shutting down because for
  52      * example bundle is being stopped.
  53      *
  54      */
  55     public void destroy() {
  56     }
  57
  58     /**
  59      * Function called by dependency manager after "init ()" is called and after
  60      * the services provided by the class are registered in the service registry
  61      *
  62      */
  63     public void start() {
  64     }
  65
  66     /**
  67      * Function called by the dependency manager before the services exported by
  68      * the component are unregistered, this will be followed by a "destroy ()"
  69      * calls
  70      *
  71      */
  72     public void stop() {
  73     }
  74
  75     /**
  76      * Retrieve nodes from openflow
  77      */
  78     @Override
  79     public ConcurrentMap<Node, Map<String, Property>> getNodeProps() {
  80         return nodeProps;
  81     }
  82
  83     /**
  84      * Retrieve nodeConnectors from openflow
  85      */
  86     @Override
  87     public ConcurrentMap<NodeConnector, Map<String, Property>> getNodeConnectorProps(
  88             Boolean refresh) {
  89         return nodeConnectorProps;
  90     }
  91
  92
  93     @Override
  94     public Map<String, Map<String, Table<?>>> getCache(Node n) {
  95         NodeDB db = dbCache.get(n);
  96         if (db == null) return null;
  97         return db.getTableCache();
  98     }
  99
 100
 101     @Override
 102     public Map<String, Table<?>> getTableCache(Node n, String tableName) {
 103         NodeDB db = dbCache.get(n);
 104         if (db == null) return null;
 105         return db.getTableCache(tableName);
 106     }
 107
 108
 109     @Override
 110     public Table<?> getRow(Node n, String tableName, String uuid) {
 111         NodeDB db = dbCache.get(n);
 112         if (db == null) return null;
 113         return db.getRow(tableName, uuid);
 114     }
 115
 116     @Override
 117     public void updateRow(Node n, String tableName, String uuid, Table<?> row) {
 118         NodeDB db = dbCache.get(n);
 119         if (db == null) {
 120             db = new NodeDB();
 121             dbCache.put(n, db);
 122         }
 123         db.updateRow(tableName, uuid, row);
 124     }
 125
 126     @Override
 127     public void removeRow(Node n, String tableName, String uuid) {
 128         NodeDB db = dbCache.get(n);
 129         if (db != null) db.removeRow(tableName, uuid);
 130     }
 131
 132     @Override
 133     public void processTableUpdates(Node n, TableUpdates tableUpdates) {
 134         NodeDB db = dbCache.get(n);
 135         if (db == null) {
 136             db = new NodeDB();
 137             dbCache.put(n, db);
 138         }
 139
 140         Set<Table.Name> available = tableUpdates.availableUpdates();
 141         for (Table.Name name : available) {
 142             TableUpdate tableUpdate = tableUpdates.getUpdate(name);
 143             Collection<TableUpdate.Row<?>> rows = tableUpdate.getRows();
 144             for (Row<?> row : rows) {
 145                 String uuid = row.getId();
 146                 Table<?> newRow = (Table<?>)row.getNew();
 147                 Table<?> oldRow = (Table<?>)row.getOld();
 148                 if (newRow != null) {
 149                     db.updateRow(name.getName(), uuid, newRow);
 150                 } else if (oldRow != null) {
 151                     db.removeRow(name.getName(), uuid);
 152                 }
 153             }
 154         }
 155     }
 156
 157     @Override
 158     public void printCache(Node n) {
 159         NodeDB db = dbCache.get(n);
 160         if (db != null) db.printTableCache();
 161     }
 162
 163     @Override
 164     public void addNodeProperty(Node n, Property prop) {
 165         Map<String, Property> nProp = nodeProps.get(n);
 166         if (nProp == null) nProp = new HashMap<String, Property>();
 167         nProp.put(prop.getName(), prop);
 168         nodeProps.put(n, nProp);
 169     }
 170
 171     @Override
 172     public DatabaseSchema getDatabaseSchema(Node n) {
 173         NodeDB db = dbCache.get(n);
 174         if (db != null) return db.getSchema();
 175         return null;
 176     }
 177
 178     @Override
 179     public void updateDatabaseSchema(Node n, DatabaseSchema schema) {
 180         NodeDB db = dbCache.get(n);
 181         if (db == null) {
 182             db = new NodeDB();
 183             dbCache.put(n, db);
 184         }
 185         db.setSchema(schema);
 186     }
 187 }