Merge lp:~rohitagarwalla/neutron/l2network-plugin-db into lp:~cisco-openstack/neutron/plugin-framework

[Rohit Agarwalla]

persistence of l2network & ucs plugins using mysql
- db_conn.ini - configuration details of making a connection to the database
- db_test_plugin.py - contains abstraction methods for storing database values in a dict and unit test cases for DB testing
- l2network_db.py - db methods for l2network models
- l2network_models.py - class definitions for the l2 network tables
- ucs_db.py - db methods for ucs models
- ucs_models.py - class definition for the ucs tables
dynamic loading of the 2nd layer plugin db's based on passed arguments
Create, Delete, Get, Getall, Update database methods at - Quantum, L2Network and Ucs
Unit test cases for create, delete, getall and update operations for L2Network and Ucs plugins
pep8 checks done
branch based off revision 34 plugin-framework

[Sumit Naiksatam (snaiksat)]

Thanks, great job! Looks mostly good to me. I ran the tests provided with this code and they executed fine. Just a few small fixes suggested (some are nits):

1. As discussed in a separate thread, please move the code to the new "db' directory.

2. The quantum component is following the convention of "getting" a logger component and logging to that (so that the logs get flagged with the name of the component). Can you please do this in the modules in which you are writing to the logs? This is how to do it:

from quantum.plugins.cisco.common import cisco_constants as const

LOG.basicConfig(level=LOG.WARN)
LOG.getLogger(const.LOGGER_COMPONENT_NAME)

3. The requirement for the creation of "cisco_naas" DB should be documented in the README file. Please also provide instructions on how to create it.

4. Specifically on the name "cisco_naas", Ram earlier had the suggestion that it be called something else. I would definitely recommend getting away from "naas" since we are not using it any more. Maybe call it "quantum_l2network" since we are calling our plugin "l2network-plugin".

5. The nova coding guidelines require that imports be arranged in the alphabetical order. The following order does not seem correct to me, please check this (and other places as well):

+import ConfigParser
33 +import os
34 +import logging as LOG
35 +import unittest
36 +from optparse import OptionParser

More info on imports order can be found in the HACKING file in the nova branch.

review: Needs Fixing

[lp:~rohitagarwalla/neutron/l2network-plugin-db]

36. By Rohit Agarwalla on 2011-08-01

merged the latest changes from plugin-framework branch - revision 39
conforming to the new cisco plugin directory structure and moving all db related modules into cisco/db folder
updated db_test_plugin.py
 - added import of cisco constants module
 - added LOG.getLogger for logging component name
 - updated import module paths for l2network_models/db and ucs_models/db to use the new directory structure
 - updated (rearranged) imports section to obey openstack alphabetical placement convention
updated db_conn.ini
 - updated database name from cisco_naas to quantum_l2network
unit test cases ran successfully and pep8 checks done again

[Sumit Naiksatam (snaiksat)]

Great, lgtm. I recommend going ahead with the merge. Thanks!

review: Approve

=== modified file 'quantum/plugins/cisco/README'
--- quantum/plugins/cisco/README	2011-07-31 18:38:26 +0000
+++ quantum/plugins/cisco/README	2011-08-01 03:39:28 +0000
@@ -76,3 +76,11 @@
 /usr/lib/python2.6/site-packages/nova/virt/cisco_ucs.py
 
 * Restart nova-compute service
+
+**L2network database usage requirements -
+* mysql database "quantum_l2network" is required for persistence of the l2network plugin data.
+	+ The database can be created as follows -
+		- # mysql -uroot -pnova; (username/password here is root/nova)
+		- mysql> create database quantum_l2network;
+		- mysql> use quantum_l2network;
+	+ The database and login details must be specified in quantum/plugins/cisco/db/db_conn.ini.

=== added file 'quantum/plugins/cisco/db/db_conn.ini'
--- quantum/plugins/cisco/db/db_conn.ini	1970-01-01 00:00:00 +0000
+++ quantum/plugins/cisco/db/db_conn.ini	2011-08-01 03:39:28 +0000
@@ -0,0 +1,5 @@
+[DATABASE]
+name = quantum_l2network
+user = root
+pass = nova
+host = 127.0.0.1

=== added file 'quantum/plugins/cisco/db/db_test_plugin.py'
--- quantum/plugins/cisco/db/db_test_plugin.py	1970-01-01 00:00:00 +0000
+++ quantum/plugins/cisco/db/db_test_plugin.py	2011-08-01 03:39:28 +0000
@@ -0,0 +1,1049 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011, Cisco Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+# @author: Rohit Agarwalla, Cisco Systems, Inc.
+
+import ConfigParser
+import os
+import logging as LOG
+import unittest
+
+from optparse import OptionParser
+from quantum.plugins.cisco.common import cisco_constants as const
+
+import quantum.db.api as db
+import quantum.db.models
+import quantum.plugins.cisco.db.l2network_db as l2network_db
+import quantum.plugins.cisco.db.l2network_models
+
+CONF_FILE = "db_conn.ini"
+LOG.getLogger(const.LOGGER_COMPONENT_NAME)
+
+
+def find_config(basepath):
+    for root, dirs, files in os.walk(basepath):
+        if CONF_FILE in files:
+            return os.path.join(root, CONF_FILE)
+    return None
+
+
+def db_conf(configfile=None):
+    config = ConfigParser.ConfigParser()
+    if configfile == None:
+        if os.path.exists(CONF_FILE):
+            configfile = CONF_FILE
+        else:
+            configfile = \
+           find_config(os.path.abspath(os.path.dirname(__file__)))
+    if configfile == None:
+        raise Exception("Configuration file \"%s\" doesn't exist" %
+              (configfile))
+    LOG.debug("Using configuration file: %s" % configfile)
+    config.read(configfile)
+
+    DB_NAME = config.get("DATABASE", "name")
+    DB_USER = config.get("DATABASE", "user")
+    DB_PASS = config.get("DATABASE", "pass")
+    DB_HOST = config.get("DATABASE", "host")
+    options = {"sql_connection": "mysql://%s:%s@%s/%s" % (DB_USER,
+    DB_PASS, DB_HOST, DB_NAME)}
+    db.configure_db(options)
+
+
+class UcsDB(object):
+    def get_all_ucsmbindings(self):
+        bindings = []
+        try:
+            for x in ucs_db.get_all_ucsmbinding():
+                LOG.debug("Getting ucsm binding : %s" % x.ucsm_ip)
+                bind_dict = {}
+                bind_dict["ucsm-ip"] = str(x.ucsm_ip)
+                bind_dict["network-id"] = str(x.network_id)
+                bindings.append(bind_dict)
+        except Exception, e:
+            LOG.error("Failed to get all bindings: %s" % str(e))
+        return bindings
+
+    def get_ucsmbinding(self, ucsm_ip):
+        binding = []
+        try:
+            for x in ucs_db.get_ucsmbinding(ucsm_ip):
+                LOG.debug("Getting ucsm binding : %s" % x.ucsm_ip)
+                bind_dict = {}
+                bind_dict["ucsm-ip"] = str(res.ucsm_ip)
+                bind_dict["network-id"] = str(res.network_id)
+                binding.append(bind_dict)
+        except Exception, e:
+            LOG.error("Failed to get binding: %s" % str(e))
+        return binding
+
+    def create_ucsmbinding(self, ucsm_ip, networ_id):
+        bind_dict = {}
+        try:
+            res = ucs_db.add_ucsmbinding(ucsm_ip, networ_id)
+            LOG.debug("Created ucsm binding: %s" % res.ucsm_ip)
+            bind_dict["ucsm-ip"] = str(res.ucsm_ip)
+            bind_dict["network-id"] = str(res.network_id)
+            return bind_dict
+        except Exception, e:
+            LOG.error("Failed to create ucsm binding: %s" % str(e))
+
+    def delete_ucsmbinding(self, ucsm_ip):
+        try:
+            res = ucs_db.remove_ucsmbinding(ucsm_ip)
+            LOG.debug("Deleted ucsm binding : %s" % res.ucsm_ip)
+            bind_dict = {}
+            bind_dict["ucsm-ip"] = str(res.ucsm_ip)
+            return bind_dict
+        except Exception, e:
+            raise Exception("Failed to delete dynamic vnic: %s" % str(e))
+
+    def update_ucsmbinding(self, ucsm_ip, network_id):
+        try:
+            res = ucs_db.update_ucsmbinding(ucsm_ip, network_id)
+            LOG.debug("Updating ucsm binding : %s" % res.ucsm_ip)
+            bind_dict = {}
+            bind_dict["ucsm-ip"] = str(res.ucsm_ip)
+            bind_dict["network-id"] = str(res.network_id)
+            return bind_dict
+        except Exception, e:
+            raise Exception("Failed to update dynamic vnic: %s" % str(e))
+
+    def get_all_dynamicvnics(self):
+        vnics = []
+        try:
+            for x in ucs_db.get_all_dynamicvnics():
+                LOG.debug("Getting dynamic vnic : %s" % x.uuid)
+                vnic_dict = {}
+                vnic_dict["vnic-id"] = str(x.uuid)
+                vnic_dict["device-name"] = x.device_name
+                vnic_dict["blade-id"] = str(x.blade_id)
+                vnics.append(vnic_dict)
+        except Exception, e:
+            LOG.error("Failed to get all dynamic vnics: %s" % str(e))
+        return vnics
+
+    def get_dynamicvnic(self, vnic_id):
+        vnic = []
+        try:
+            for x in ucs_db.get_dynamicvnic(vnic_id):
+                LOG.debug("Getting dynamic vnic : %s" % x.uuid)
+                vnic_dict = {}
+                vnic_dict["vnic-id"] = str(x.uuid)
+                vnic_dict["device-name"] = x.device_name
+                vnic_dict["blade-id"] = str(x.blade_id)
+                vnic.append(vnic_dict)
+        except Exception, e:
+            LOG.error("Failed to get dynamic vnic: %s" % str(e))
+        return vnic
+
+    def create_dynamicvnic(self, device_name, blade_id):
+        vnic_dict = {}
+        try:
+            res = ucs_db.add_dynamicvnic(device_name, blade_id)
+            LOG.debug("Created dynamic vnic: %s" % res.uuid)
+            vnic_dict["vnic-id"] = str(res.uuid)
+            vnic_dict["device-name"] = res.device_name
+            vnic_dict["blade-id"] = str(res.blade_id)
+            return vnic_dict
+        except Exception, e:
+            LOG.error("Failed to create dynamic vnic: %s" % str(e))
+
+    def delete_dynamicvnic(self, vnic_id):
+        try:
+            res = ucs_db.remove_dynamicvnic(vnic_id)
+            LOG.debug("Deleted dynamic vnic : %s" % res.uuid)
+            vnic_dict = {}
+            vnic_dict["vnic-id"] = str(res.uuid)
+            return vnic_dict
+        except Exception, e:
+            raise Exception("Failed to delete dynamic vnic: %s" % str(e))
+
+    def update_dynamicvnic(self, vnic_id, device_name=None, blade_id=None):
+        try:
+            res = ucs_db.update_dynamicvnic(vnic_id, device_name, blade_id)
+            LOG.debug("Updating dynamic vnic : %s" % res.uuid)
+            vnic_dict = {}
+            vnic_dict["vnic-id"] = str(res.uuid)
+            vnic_dict["device-name"] = res.device_name
+            vnic_dict["blade-id"] = str(res.blade_id)
+            return vnic_dict
+        except Exception, e:
+            raise Exception("Failed to update dynamic vnic: %s" % str(e))
+
+    def get_all_blades(self):
+        blades = []
+        try:
+            for x in ucs_db.get_all_blades():
+                LOG.debug("Getting blade : %s" % x.uuid)
+                blade_dict = {}
+                blade_dict["blade-id"] = str(x.uuid)
+                blade_dict["mgmt-ip"] = str(x.mgmt_ip)
+                blade_dict["mac-addr"] = str(x.mac_addr)
+                blade_dict["chassis-id"] = str(x.chassis_id)
+                blade_dict["ucsm-ip"] = str(x.ucsm_ip)
+                blades.append(blade_dict)
+        except Exception, e:
+            LOG.error("Failed to get all blades: %s" % str(e))
+        return blades
+
+    def get_blade(self, blade_id):
+        blade = []
+        try:
+            for x in ucs_db.get_blade(blade_id):
+                LOG.debug("Getting blade : %s" % x.uuid)
+                blade_dict = {}
+                blade_dict["blade-id"] = str(x.uuid)
+                blade_dict["mgmt-ip"] = str(x.mgmt_ip)
+                blade_dict["mac-addr"] = str(x.mac_addr)
+                blade_dict["chassis-id"] = str(x.chassis_id)
+                blade_dict["ucsm-ip"] = str(x.ucsm_ip)
+                blade.append(blade_dict)
+        except Exception, e:
+            LOG.error("Failed to get all blades: %s" % str(e))
+        return blade
+
+    def create_blade(self, mgmt_ip, mac_addr, chassis_id, ucsm_ip):
+        blade_dict = {}
+        try:
+            res = ucs_db.add_blade(mgmt_ip, mac_addr, chassis_id, ucsm_ip)
+            LOG.debug("Created blade: %s" % res.uuid)
+            blade_dict["blade-id"] = str(res.uuid)
+            blade_dict["mgmt-ip"] = str(res.mgmt_ip)
+            blade_dict["mac-addr"] = str(res.mac_addr)
+            blade_dict["chassis-id"] = str(res.chassis_id)
+            blade_dict["ucsm-ip"] = str(res.ucsm_ip)
+            return blade_dict
+        except Exception, e:
+            LOG.error("Failed to create blade: %s" % str(e))
+
+    def delete_blade(self, blade_id):
+        try:
+            res = ucs_db.remove_blade(blade_id)
+            LOG.debug("Deleted blade : %s" % res.uuid)
+            blade_dict = {}
+            blade_dict["blade-id"] = str(res.uuid)
+            return blade_dict
+        except Exception, e:
+            raise Exception("Failed to delete blade: %s" % str(e))
+
+    def update_blade(self, blade_id, mgmt_ip=None, mac_addr=None,\
+                     chassis_id=None, ucsm_ip=None):
+        try:
+            res = ucs_db.update_blade(blade_id, mgmt_ip, mac_addr, \
+                                      chassis_id, ucsm_ip)
+            LOG.debug("Updating blade : %s" % res.uuid)
+            blade_dict = {}
+            blade_dict["blade-id"] = str(res.uuid)
+            blade_dict["mgmt-ip"] = str(res.mgmt_ip)
+            blade_dict["mac-addr"] = str(res.mac_addr)
+            blade_dict["chassis-id"] = str(res.chassis_id)
+            blade_dict["ucsm-ip"] = str(res.ucsm_ip)
+            return blade_dict
+        except Exception, e:
+            raise Exception("Failed to update blade: %s" % str(e))
+
+    def get_all_port_bindings(self):
+        port_bindings = []
+        try:
+            for x in ucs_db.get_all_portbindings():
+                LOG.debug("Getting port binding for port: %s" % x.port_id)
+                port_bind_dict = {}
+                port_bind_dict["port-id"] = x.port_id
+                port_bind_dict["dynamic-vnic-id"] = str(x.dynamic_vnic_id)
+                port_bind_dict["portprofile-name"] = x.portprofile_name
+                port_bind_dict["vlan-name"] = x.vlan_name
+                port_bind_dict["vlan-id"] = str(x.vlan_id)
+                port_bind_dict["qos"] = x.qos
+                port_bindings.append(port_bind_dict)
+        except Exception, e:
+            LOG.error("Failed to get all port bindings: %s" % str(e))
+        return port_bindings
+
+    def get_port_binding(self):
+        port_binding = []
+        try:
+            for x in ucs_db.get_portbinding(port_id):
+                LOG.debug("Getting port binding for port: %s" % x.port_id)
+                port_bind_dict = {}
+                port_bind_dict["port-id"] = x.port_id
+                port_bind_dict["dynamic-vnic-id"] = str(x.dynamic_vnic_id)
+                port_bind_dict["portprofile-name"] = x.portprofile_name
+                port_bind_dict["vlan-name"] = x.vlan_name
+                port_bind_dict["vlan-id"] = str(x.vlan_id)
+                port_bind_dict["qos"] = x.qos
+                port_bindings.append(port_bind_dict)
+        except Exception, e:
+            LOG.error("Failed to get port binding: %s" % str(e))
+        return port_binding
+
+    def create_port_binding(self, port_id, dynamic_vnic_id, portprofile_name, \
+                            vlan_name, vlan_id, qos):
+        port_bind_dict = {}
+        try:
+            res = ucs_db.add_portbinding(port_id, dynamic_vnic_id, \
+                                  portprofile_name, vlan_name, vlan_id, qos)
+            LOG.debug("Created port binding: %s" % res.port_id)
+            port_bind_dict["port-id"] = res.port_id
+            port_bind_dict["dynamic-vnic-id"] = str(res.dynamic_vnic_id)
+            port_bind_dict["portprofile-name"] = res.portprofile_name
+            port_bind_dict["vlan-name"] = res.vlan_name
+            port_bind_dict["vlan-id"] = str(res.vlan_id)
+            port_bind_dict["qos"] = res.qos
+            return port_bind_dict
+        except Exception, e:
+            LOG.error("Failed to create port binding: %s" % str(e))
+
+    def delete_port_binding(self, port_id):
+        try:
+            res = ucs_db.remove_portbinding(port_id)
+            LOG.debug("Deleted port binding : %s" % res.port_id)
+            port_bind_dict = {}
+            port_bind_dict["port-id"] = res.port_id
+            return port_bind_dict
+        except Exception, e:
+            raise Exception("Failed to delete port profile: %s" % str(e))
+
+    def update_port_binding(self, port_id, dynamic_vnic_id, \
+                         portprofile_name, vlan_name, vlan_id, qos):
+        try:
+            res = ucs_db.update_portbinding(port_id, dynamic_vnic_id, \
+                               portprofile_name, vlan_name, vlan_id, qos)
+            LOG.debug("Updating port binding: %s" % res.port_id)
+            port_bind_dict = {}
+            port_bind_dict["port-id"] = res.port_id
+            port_bind_dict["dynamic-vnic-id"] = str(res.dynamic_vnic_id)
+            port_bind_dict["portprofile-name"] = res.portprofile_name
+            port_bind_dict["vlan-name"] = res.vlan_name
+            port_bind_dict["vlan-id"] = str(res.vlan_id)
+            port_bind_dict["qos"] = res.qos
+            return port_bind_dict
+        except Exception, e:
+            raise Exception("Failed to update portprofile binding:%s" % str(e))
+
+
+class QuantumDB(object):
+    def get_all_networks(self, tenant_id):
+        nets = []
+        try:
+            for x in db.network_list(tenant_id):
+                LOG.debug("Getting network: %s" % x.uuid)
+                net_dict = {}
+                net_dict["tenant-id"] = x.tenant_id
+                net_dict["net-id"] = str(x.uuid)
+                net_dict["net-name"] = x.name
+                nets.append(net_dict)
+        except Exception, e:
+            LOG.error("Failed to get all networks: %s" % str(e))
+        return nets
+
+    def get_network(self, network_id):
+        net = []
+        try:
+            for x in db.network_get(network_id):
+                LOG.debug("Getting network: %s" % x.uuid)
+                net_dict = {}
+                net_dict["tenant-id"] = x.tenant_id
+                net_dict["net-id"] = str(x.uuid)
+                net_dict["net-name"] = x.name
+                nets.append(net_dict)
+        except Exception, e:
+            LOG.error("Failed to get network: %s" % str(e))
+        return net
+
+    def create_network(self, tenant_id, net_name):
+        net_dict = {}
+        try:
+            res = db.network_create(tenant_id, net_name)
+            LOG.debug("Created network: %s" % res.uuid)
+            net_dict["tenant-id"] = res.tenant_id
+            net_dict["net-id"] = str(res.uuid)
+            net_dict["net-name"] = res.name
+            return net_dict
+        except Exception, e:
+            LOG.error("Failed to create network: %s" % str(e))
+
+    def delete_network(self, net_id):
+        try:
+            net = db.network_destroy(net_id)
+            LOG.debug("Deleted network: %s" % net.uuid)
+            net_dict = {}
+            net_dict["net-id"] = str(net.uuid)
+            return net_dict
+        except Exception, e:
+            raise Exception("Failed to delete port: %s" % str(e))
+
+    def rename_network(self, tenant_id, net_id, new_name):
+        try:
+            net = db.network_rename(net_id, tenant_id, new_name)
+            LOG.debug("Renamed network: %s" % net.uuid)
+            net_dict = {}
+            net_dict["net-id"] = str(net.uuid)
+            net_dict["net-name"] = net.name
+            return net_dict
+        except Exception, e:
+            raise Exception("Failed to rename network: %s" % str(e))
+
+    def get_all_ports(self, net_id):
+        ports = []
+        try:
+            for x in db.port_list(net_id):
+                LOG.debug("Getting port: %s" % x.uuid)
+                port_dict = {}
+                port_dict["port-id"] = str(x.uuid)
+                port_dict["net-id"] = str(x.network_id)
+                port_dict["int-id"] = x.interface_id
+                port_dict["state"] = x.state
+                ports.append(port_dict)
+            return ports
+        except Exception, e:
+            LOG.error("Failed to get all ports: %s" % str(e))
+
+    def get_port(self, port_id):
+        port = []
+        try:
+            for x in db.port_get(port_id):
+                LOG.debug("Getting port: %s" % x.uuid)
+                port_dict = {}
+                port_dict["port-id"] = str(x.uuid)
+                port_dict["net-id"] = str(x.network_id)
+                port_dict["int-id"] = x.interface_id
+                port_dict["state"] = x.state
+                port.append(port_dict)
+            return port
+        except Exception, e:
+            LOG.error("Failed to get port: %s" % str(e))
+
+    def create_port(self, net_id):
+        port_dict = {}
+        try:
+            port = db.port_create(net_id)
+            LOG.debug("Creating port %s" % port.uuid)
+            port_dict["port-id"] = str(port.uuid)
+            port_dict["net-id"] = str(port.network_id)
+            port_dict["int-id"] = port.interface_id
+            port_dict["state"] = port.state
+            return port_dict
+        except Exception, e:
+            LOG.error("Failed to create port: %s" % str(e))
+
+    def delete_port(self, port_id):
+        try:
+            port = db.port_destroy(port_id)
+            LOG.debug("Deleted port %s" % port.uuid)
+            port_dict = {}
+            port_dict["port-id"] = str(port.uuid)
+            return port_dict
+        except Exception, e:
+            raise Exception("Failed to delete port: %s" % str(e))
+
+    def update_port(self, port_id, port_state):
+        try:
+            port = db.port_set_state(port_id, port_state)
+            LOG.debug("Updated port %s" % port.uuid)
+            port_dict = {}
+            port_dict["port-id"] = str(port.uuid)
+            port_dict["net-id"] = str(port.network_id)
+            port_dict["int-id"] = port.interface_id
+            port_dict["state"] = port.state
+            return port_dict
+        except Exception, e:
+            raise Exception("Failed to update port state: %s" % str(e))
+
+
+class L2networkDB(object):
+    def get_all_vlan_bindings(self):
+        vlans = []
+        try:
+            for x in l2network_db.get_all_vlan_bindings():
+                LOG.debug("Getting vlan bindings for vlan: %s" % x.vlan_id)
+                vlan_dict = {}
+                vlan_dict["vlan-id"] = str(x.vlan_id)
+                vlan_dict["vlan-name"] = x.vlan_name
+                vlan_dict["net-id"] = str(x.network_id)
+                vlans.append(vlan_dict)
+        except Exception, e:
+            LOG.error("Failed to get all vlan bindings: %s" % str(e))
+        return vlans
+
+    def get_vlan_binding(self, network_id):
+        vlan = []
+        try:
+            for x in l2network_db.get_vlan_binding(network_id):
+                LOG.debug("Getting vlan binding for vlan: %s" % x.vlan_id)
+                vlan_dict = {}
+                vlan_dict["vlan-id"] = str(x.vlan_id)
+                vlan_dict["vlan-name"] = x.vlan_name
+                vlan_dict["net-id"] = str(x.network_id)
+                vlan.append(vlan_dict)
+        except Exception, e:
+            LOG.error("Failed to get vlan binding: %s" % str(e))
+        return vlan
+
+    def create_vlan_binding(self, vlan_id, vlan_name, network_id):
+        vlan_dict = {}
+        try:
+            res = l2network_db.add_vlan_binding(vlan_id, vlan_name, network_id)
+            LOG.debug("Created vlan binding for vlan: %s" % res.vlan_id)
+            vlan_dict["vlan-id"] = str(res.vlan_id)
+            vlan_dict["vlan-name"] = res.vlan_name
+            vlan_dict["net-id"] = str(res.network_id)
+            return vlan_dict
+        except Exception, e:
+            LOG.error("Failed to create vlan binding: %s" % str(e))
+
+    def delete_vlan_binding(self, network_id):
+        try:
+            res = l2network_db.remove_vlan_binding(network_id)
+            LOG.debug("Deleted vlan binding for vlan: %s" % res.vlan_id)
+            vlan_dict = {}
+            vlan_dict["vlan-id"] = str(res.vlan_id)
+            return vlan_dict
+        except Exception, e:
+            raise Exception("Failed to delete vlan binding: %s" % str(e))
+
+    def update_vlan_binding(self, network_id, vlan_id, vlan_name):
+        try:
+            res = l2network_db.update_vlan_binding(network_id, vlan_id, \
+                                                            vlan_name)
+            LOG.debug("Updating vlan binding for vlan: %s" % res.vlan_id)
+            vlan_dict = {}
+            vlan_dict["vlan-id"] = str(res.vlan_id)
+            vlan_dict["vlan-name"] = res.vlan_name
+            vlan_dict["net-id"] = str(res.network_id)
+            return vlan_dict
+        except Exception, e:
+            raise Exception("Failed to update vlan binding: %s" % str(e))
+
+    def get_all_portprofiles(self):
+        pps = []
+        try:
+            for x in l2network_db.get_all_portprofiles():
+                LOG.debug("Getting port profile : %s" % x.uuid)
+                pp_dict = {}
+                pp_dict["portprofile-id"] = str(x.uuid)
+                pp_dict["portprofile-name"] = x.name
+                pp_dict["vlan-id"] = str(x.vlan_id)
+                pp_dict["qos"] = x.qos
+                pps.append(pp_dict)
+        except Exception, e:
+            LOG.error("Failed to get all port profiles: %s" % str(e))
+        return pps
+
+    def get_portprofile(self, port_id):
+        pp = []
+        try:
+            for x in l2network_db.get_portprofile(port_id):
+                LOG.debug("Getting port profile : %s" % x.uuid)
+                pp_dict = {}
+                pp_dict["portprofile-id"] = str(x.uuid)
+                pp_dict["portprofile-name"] = x.name
+                pp_dict["vlan-id"] = str(x.vlan_id)
+                pp_dict["qos"] = x.qos
+                pp.append(pp_dict)
+        except Exception, e:
+            LOG.error("Failed to get port profile: %s" % str(e))
+        return pp
+
+    def create_portprofile(self, name, vlan_id, qos):
+        pp_dict = {}
+        try:
+            res = l2network_db.add_portprofile(name, vlan_id, qos)
+            LOG.debug("Created port profile: %s" % res.uuid)
+            pp_dict["portprofile-id"] = str(res.uuid)
+            pp_dict["portprofile-name"] = res.name
+            pp_dict["vlan-id"] = str(res.vlan_id)
+            pp_dict["qos"] = res.qos
+            return pp_dict
+        except Exception, e:
+            LOG.error("Failed to create port profile: %s" % str(e))
+
+    def delete_portprofile(self, pp_id):
+        try:
+            res = l2network_db.remove_portprofile(pp_id)
+            LOG.debug("Deleted port profile : %s" % res.uuid)
+            pp_dict = {}
+            pp_dict["pp-id"] = str(res.uuid)
+            return pp_dict
+        except Exception, e:
+            raise Exception("Failed to delete port profile: %s" % str(e))
+
+    def update_portprofile(self, pp_id, name, vlan_id, qos):
+        try:
+            res = l2network_db.update_portprofile(pp_id, name, vlan_id, qos)
+            LOG.debug("Updating port profile : %s" % res.uuid)
+            pp_dict = {}
+            pp_dict["portprofile-id"] = str(res.uuid)
+            pp_dict["portprofile-name"] = res.name
+            pp_dict["vlan-id"] = str(res.vlan_id)
+            pp_dict["qos"] = res.qos
+            return pp_dict
+        except Exception, e:
+            raise Exception("Failed to update port profile: %s" % str(e))
+
+    def get_all_pp_bindings(self):
+        pp_bindings = []
+        try:
+            for x in l2network_db.get_all_pp_bindings():
+                LOG.debug("Getting port profile binding: %s" % \
+                                               x.portprofile_id)
+                ppbinding_dict = {}
+                ppbinding_dict["portprofile-id"] = str(x.portprofile_id)
+                ppbinding_dict["net-id"] = str(x.network_id)
+                ppbinding_dict["tenant-id"] = x.tenant_id
+                ppbinding_dict["default"] = x.default
+                pp_bindings.append(ppbinding_dict)
+        except Exception, e:
+            LOG.error("Failed to get all port profiles: %s" % str(e))
+        return pp_bindings
+
+    def get_pp_binding(self, pp_id):
+        pp_binding = []
+        try:
+            for x in l2network_db.get_pp_binding(pp_id):
+                LOG.debug("Getting port profile binding: %s" % \
+                                                 x.portprofile_id)
+                ppbinding_dict = {}
+                ppbinding_dict["portprofile-id"] = str(x.portprofile_id)
+                ppbinding_dict["net-id"] = str(x.network_id)
+                ppbinding_dict["tenant-id"] = x.tenant_id
+                ppbinding_dict["default"] = x.default
+                pp_bindings.append(ppbinding_dict)
+        except Exception, e:
+            LOG.error("Failed to get port profile binding: %s" % str(e))
+        return pp_binding
+
+    def create_pp_binding(self, tenant_id, net_id, pp_id, default):
+        ppbinding_dict = {}
+        try:
+            res = l2network_db.add_pp_binding(tenant_id, net_id, pp_id, \
+                                                                default)
+            LOG.debug("Created port profile binding: %s" % res.portprofile_id)
+            ppbinding_dict["portprofile-id"] = str(res.portprofile_id)
+            ppbinding_dict["net-id"] = str(res.network_id)
+            ppbinding_dict["tenant-id"] = res.tenant_id
+            ppbinding_dict["default"] = res.default
+            return ppbinding_dict
+        except Exception, e:
+            LOG.error("Failed to create port profile binding: %s" % str(e))
+
+    def delete_pp_binding(self, pp_id):
+        try:
+            res = l2network_db.remove_pp_binding(pp_id)
+            LOG.debug("Deleted port profile binding : %s" % res.portprofile_id)
+            ppbinding_dict = {}
+            ppbinding_dict["portprofile-id"] = str(res.portprofile_id)
+            return ppbinding_dict
+        except Exception, e:
+            raise Exception("Failed to delete port profile: %s" % str(e))
+
+    def update_pp_binding(self, pp_id, tenant_id, net_id, default):
+        try:
+            res = l2network_db.update_pp_binding(pp_id, tenant_id, net_id,\
+                                                                   default)
+            LOG.debug("Updating port profile binding: %s" % res.portprofile_id)
+            ppbinding_dict = {}
+            ppbinding_dict["portprofile-id"] = str(res.portprofile_id)
+            ppbinding_dict["net-id"] = str(res.network_id)
+            ppbinding_dict["tenant-id"] = res.tenant_id
+            ppbinding_dict["default"] = res.default
+            return ppbinding_dict
+        except Exception, e:
+            raise Exception("Failed to update portprofile binding:%s" % str(e))
+
+
+class UcsDBTest(unittest.TestCase):
+    def setUp(self):
+        self.dbtest = UcsDB()
+        LOG.debug("Setup")
+
+    def testACreateUcsmBinding(self):
+        binding1 = self.dbtest.create_ucsmbinding("1.2.3.4", "net1")
+        self.assertTrue(binding1["ucsm-ip"] == "1.2.3.4")
+        self.tearDownUcsmBinding()
+
+    def testBGetAllUcsmBindings(self):
+        binding1 = self.dbtest.create_ucsmbinding("1.2.3.4", "net1")
+        binding2 = self.dbtest.create_ucsmbinding("2.3.4.5", "net1")
+        bindings = self.dbtest.get_all_ucsmbindings()
+        count = 0
+        for x in bindings:
+            if "net" in x["network-id"]:
+                count += 1
+        self.assertTrue(count == 2)
+        self.tearDownUcsmBinding()
+
+    def testCDeleteUcsmBinding(self):
+        binding1 = self.dbtest.create_ucsmbinding("1.2.3.4", "net1")
+        self.dbtest.delete_ucsmbinding(binding1["ucsm-ip"])
+        bindings = self.dbtest.get_all_ucsmbindings()
+        count = 0
+        for x in bindings:
+            if "net " in x["network-id"]:
+                count += 1
+        self.assertTrue(count == 0)
+        self.tearDownUcsmBinding()
+
+    def testDUpdateUcsmBinding(self):
+        binding1 = self.dbtest.create_ucsmbinding("1.2.3.4", "net1")
+        binding1 = self.dbtest.update_ucsmbinding(binding1["ucsm-ip"], \
+                                                             "newnet1")
+        bindings = self.dbtest.get_all_ucsmbindings()
+        count = 0
+        for x in bindings:
+            if "new" in x["network-id"]:
+                count += 1
+        self.assertTrue(count == 1)
+        self.tearDownUcsmBinding()
+
+    def testECreateDynamicVnic(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                               "9.8.7.6")
+        vnic1 = self.dbtest.create_dynamicvnic("eth1", blade1["blade-id"])
+        self.assertTrue(vnic1["device-name"] == "eth1")
+        self.tearDownDyanmicVnic()
+
+    def testFGetAllDyanmicVnics(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                                "9.8.7.6")
+        vnic1 = self.dbtest.create_dynamicvnic("eth1", blade1["blade-id"])
+        vnic2 = self.dbtest.create_dynamicvnic("eth2", blade1["blade-id"])
+        vnics = self.dbtest.get_all_dynamicvnics()
+        count = 0
+        for x in vnics:
+            if "eth" in x["device-name"]:
+                count += 1
+        self.assertTrue(count == 2)
+        self.tearDownDyanmicVnic()
+
+    def testGDeleteDyanmicVnic(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                               "9.8.7.6")
+        vnic1 = self.dbtest.create_dynamicvnic("eth1", blade1["blade-id"])
+        self.dbtest.delete_dynamicvnic(vnic1["vnic-id"])
+        vnics = self.dbtest.get_all_dynamicvnics()
+        count = 0
+        for x in vnics:
+            if "eth " in x["device-name"]:
+                count += 1
+        self.assertTrue(count == 0)
+        self.tearDownDyanmicVnic()
+
+    def testHUpdateDynamicVnic(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                                "9.8.7.6")
+        vnic1 = self.dbtest.create_dynamicvnic("eth1", blade1["blade-id"])
+        vnic1 = self.dbtest.update_dynamicvnic(vnic1["vnic-id"], "neweth1", \
+                                                              "newblade2")
+        vnics = self.dbtest.get_all_dynamicvnics()
+        count = 0
+        for x in vnics:
+            if "new" in x["device-name"]:
+                count += 1
+        self.assertTrue(count == 1)
+        self.tearDownDyanmicVnic()
+
+    def testICreateUcsBlade(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                              "9.8.7.6")
+        self.assertTrue(blade1["mgmt-ip"] == "1.2.3.4")
+        self.tearDownUcsBlade()
+
+    def testJGetAllUcsBlade(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                                 "9.8.7.6")
+        blade2 = self.dbtest.create_blade("2.3.4.5", "efgh", "chassis1", \
+                                                                 "9.8.7.6")
+        blades = self.dbtest.get_all_blades()
+        count = 0
+        for x in blades:
+            if "chassis" in x["chassis-id"]:
+                count += 1
+        self.assertTrue(count == 2)
+        self.tearDownUcsBlade()
+
+    def testKDeleteUcsBlade(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                                 "9.8.7.6")
+        self.dbtest.delete_blade(blade1["blade-id"])
+        blades = self.dbtest.get_all_blades()
+        count = 0
+        for x in blades:
+            if "chassis " in x["chassis-id"]:
+                count += 1
+        self.assertTrue(count == 0)
+        self.tearDownUcsBlade()
+
+    def testLUpdateUcsBlade(self):
+        blade1 = self.dbtest.create_blade("1.2.3.4", "abcd", "chassis1", \
+                                                                "9.8.7.6")
+        blade2 = self.dbtest.update_blade(blade1["blade-id"], "2.3.4.5", \
+                                          "newabcd", "chassis1", "9.8.7.6")
+        blades = self.dbtest.get_all_blades()
+        count = 0
+        for x in blades:
+            if "new" in x["mac-addr"]:
+                count += 1
+        self.assertTrue(count == 1)
+        self.tearDownUcsBlade()
+
+    def testMCreatePortBinding(self):
+        port_bind1 = self.dbtest.create_port_binding("port1", "dv1", "pp1", \
+                                                        "vlan1", 10, "qos1")
+        self.assertTrue(port_bind1["port-id"] == "port1")
+        self.tearDownPortBinding()
+
+    def testNGetAllPortBinding(self):
+        port_bind1 = self.dbtest.create_port_binding("port1", "dv1", "pp1", \
+                                                         "vlan1", 10, "qos1")
+        port_bind2 = self.dbtest.create_port_binding("port2", "dv2", "pp2", \
+                                                         "vlan2", 20, "qos2")
+        port_bindings = self.dbtest.get_all_port_bindings()
+        count = 0
+        for x in port_bindings:
+            if "port" in x["port-id"]:
+                count += 1
+        self.assertTrue(count == 2)
+        self.tearDownPortBinding()
+
+    def testODeletePortBinding(self):
+        port_bind1 = self.dbtest.create_port_binding("port1", "dv1", "pp1", \
+                                                     "vlan1", 10, "qos1")
+        self.dbtest.delete_port_binding("port1")
+        port_bindings = self.dbtest.get_all_port_bindings()
+        count = 0
+        for x in port_bindings:
+            if "port " in x["port-id"]:
+                count += 1
+        self.assertTrue(count == 0)
+        self.tearDownPortBinding()
+
+    def testPUpdatePortBinding(self):
+        port_bind1 = self.dbtest.create_port_binding("port1", "dv1", "pp1", \
+                                                     "vlan1", 10, "qos1")
+        port_bind1 = self.dbtest.update_port_binding("port1", "newdv1", \
+                                         "newpp1", "newvlan1", 11, "newqos1")
+        port_bindings = self.dbtest.get_all_port_bindings()
+        count = 0
+        for x in port_bindings:
+            if "new" in x["dynamic-vnic-id"]:
+                count += 1
+        self.assertTrue(count == 1)
+        self.tearDownPortBinding()
+
+    def tearDownUcsmBinding(self):
+        print "Tearing Down Ucsm Bindings"
+        binds = self.dbtest.get_all_ucsmbindings()
+        for bind in binds:
+            ip = bind["ucsm-ip"]
+            self.dbtest.delete_ucsmbinding(ip)
+
+    def tearDownDyanmicVnic(self):
+        print "Tearing Down Dynamic Vnics"
+        vnics = self.dbtest.get_all_dynamicvnics()
+        for vnic in vnics:
+            id = vnic["vnic-id"]
+            self.dbtest.delete_dynamicvnic(id)
+        self.tearDownUcsBlade()
+
+    def tearDownUcsBlade(self):
+        print "Tearing Down Blades"
+        blades = self.dbtest.get_all_blades()
+        for blade in blades:
+            id = blade["blade-id"]
+            self.dbtest.delete_blade(id)
+
+    def tearDownPortBinding(self):
+        print "Tearing Down Port Binding"
+        port_bindings = self.dbtest.get_all_port_bindings()
+        for port_binding in port_bindings:
+            id = port_binding["port-id"]
+            self.dbtest.delete_port_binding(id)
+
+
+class L2networkDBTest(unittest.TestCase):
+    def setUp(self):
+        self.dbtest = L2networkDB()
+        LOG.debug("Setup")
+
+    def testACreateVlanBinding(self):
+        vlan1 = self.dbtest.create_vlan_binding(10, "vlan1", "netid1")
+        self.assertTrue(vlan1["vlan-id"] == "10")
+        self.tearDownVlanBinding()
+
+    def testBGetAllVlanBindings(self):
+        vlan1 = self.dbtest.create_vlan_binding(10, "vlan1", "netid1")
+        vlan2 = self.dbtest.create_vlan_binding(20, "vlan2", "netid2")
+        vlans = self.dbtest.get_all_vlan_bindings()
+        count = 0
+        for x in vlans:
+            if "netid" in x["net-id"]:
+                count += 1
+        self.assertTrue(count == 2)
+        self.tearDownVlanBinding()
+
+    def testCDeleteVlanBinding(self):
+        vlan1 = self.dbtest.create_vlan_binding(10, "vlan1", "netid1")
+        self.dbtest.delete_vlan_binding("netid1")
+        vlans = self.dbtest.get_all_vlan_bindings()
+        count = 0
+        for x in vlans:
+            if "netid " in x["net-id"]:
+                count += 1
+        self.assertTrue(count == 0)
+        self.tearDownVlanBinding()
+
+    def testDUpdateVlanBinding(self):
+        vlan1 = self.dbtest.create_vlan_binding(10, "vlan1", "netid1")
+        vlan1 = self.dbtest.update_vlan_binding("netid1", 11, "newvlan1")
+        vlans = self.dbtest.get_all_vlan_bindings()
+        count = 0
+        for x in vlans:
+            if "new" in x["vlan-name"]:
+                count += 1
+        self.assertTrue(count == 1)
+        self.tearDownVlanBinding()
+
+    def testICreatePortProfile(self):
+        pp1 = self.dbtest.create_portprofile("portprofile1", 10, "qos1")
+        self.assertTrue(pp1["portprofile-name"] == "portprofile1")
+        self.tearDownPortProfile()
+
+    def testJGetAllPortProfile(self):
+        pp1 = self.dbtest.create_portprofile("portprofile1", 10, "qos1")
+        pp2 = self.dbtest.create_portprofile("portprofile2", 20, "qos2")
+        pps = self.dbtest.get_all_portprofiles()
+        count = 0
+        for x in pps:
+            if "portprofile" in x["portprofile-name"]:
+                count += 1
+        self.assertTrue(count == 2)
+        self.tearDownPortProfile()
+
+    def testKDeletePortProfile(self):
+        pp1 = self.dbtest.create_portprofile("portprofile1", 10, "qos1")
+        self.dbtest.delete_portprofile(pp1["portprofile-id"])
+        pps = self.dbtest.get_all_portprofiles()
+        count = 0
+        for x in pps:
+            if "portprofile " in x["portprofile-name"]:
+                count += 1
+        self.assertTrue(count == 0)
+        self.tearDownPortProfile()
+
+    def testLUpdatePortProfile(self):
+        pp1 = self.dbtest.create_portprofile("portprofile1", 10, "qos1")
+        pp1 = self.dbtest.update_portprofile(pp1["portprofile-id"], \
+                                          "newportprofile1", 20, "qos2")
+        pps = self.dbtest.get_all_portprofiles()
+        count = 0
+        for x in pps:
+            if "new" in x["portprofile-name"]:
+                count += 1
+        self.assertTrue(count == 1)
+        self.tearDownPortProfile()
+
+    def testMCreatePortProfileBinding(self):
+        pp_binding1 = self.dbtest.create_pp_binding("t1", "net1", \
+                                                    "portprofile1", "0")
+        self.assertTrue(pp_binding1["portprofile-id"] == "portprofile1")
+        self.tearDownPortProfileBinding()
+
+    def testNGetAllPortProfileBinding(self):
+        pp_binding1 = self.dbtest.create_pp_binding("t1", "net1", \
+                                                     "portprofile1", "0")
+        pp_binding2 = self.dbtest.create_pp_binding("t2", "net2", \
+                                                     "portprofile2", "0")
+        pp_bindings = self.dbtest.get_all_pp_bindings()
+        count = 0
+        for x in pp_bindings:
+            if "portprofile" in x["portprofile-id"]:
+                count += 1
+        self.assertTrue(count == 2)
+        self.tearDownPortProfileBinding()
+
+    def testODeletePortProfileBinding(self):
+        pp_binding1 = self.dbtest.create_pp_binding("t1", "net1", \
+                                                     "portprofile1", "0")
+        self.dbtest.delete_pp_binding(pp_binding1["portprofile-id"])
+        pp_bindings = self.dbtest.get_all_pp_bindings()
+        count = 0
+        for x in pp_bindings:
+            if "portprofile " in x["portprofile-id"]:
+                count += 1
+        self.assertTrue(count == 0)
+        self.tearDownPortProfileBinding()
+
+    def testPUpdatePortProfileBinding(self):
+        pp_binding1 = self.dbtest.create_pp_binding("t1", "net1", \
+                                                      "portprofile1", "0")
+        pp_binding1 = self.dbtest.update_pp_binding("portprofile1", \
+                                                  "newt1", "newnet1", "1")
+        pp_bindings = self.dbtest.get_all_pp_bindings()
+        count = 0
+        for x in pp_bindings:
+            if "new" in x["net-id"]:
+                count += 1
+        self.assertTrue(count == 1)
+        self.tearDownPortProfileBinding()
+
+    def tearDownVlanBinding(self):
+        print "Tearing Down Vlan Binding"
+        vlans = self.dbtest.get_all_vlan_bindings()
+        for vlan in vlans:
+            id = vlan["net-id"]
+            self.dbtest.delete_vlan_binding(id)
+
+    def tearDownPortProfile(self):
+        print "Tearing Down Port Profile"
+        pps = self.dbtest.get_all_portprofiles()
+        for pp in pps:
+            id = pp["portprofile-id"]
+            self.dbtest.delete_portprofile(id)
+
+    def tearDownPortProfileBinding(self):
+        print "Tearing Down Port Profile Binding"
+        pp_bindings = self.dbtest.get_all_pp_bindings()
+        for pp_binding in pp_bindings:
+            id = pp_binding["portprofile-id"]
+            self.dbtest.delete_pp_binding(id)
+
+if __name__ == "__main__":
+    usagestr = "Usage: %prog [OPTIONS] <command> [args]"
+    parser = OptionParser(usage=usagestr)
+    parser.add_option("-v", "--verbose", dest="verbose",
+      action="store_true", default=False, help="turn on verbose logging")
+
+    options, args = parser.parse_args()
+
+    if options.verbose:
+        LOG.basicConfig(level=LOG.DEBUG)
+    else:
+        LOG.basicConfig(level=LOG.WARN)
+
+    #load the models and db based on the 2nd level plugin argument
+    if args[0] == "ucs":
+        ucs_db = __import__("quantum.plugins.cisco.db.ucs_db", \
+                fromlist=["ucs_db"])
+        ucs_model = __import__("quantum.plugins.cisco.db.ucs_models", \
+                fromlist=["ucs_models"])
+
+    db_conf()
+
+    # Run the tests
+    suite = unittest.TestLoader().loadTestsFromTestCase(L2networkDBTest)
+    unittest.TextTestRunner(verbosity=2).run(suite)
+    suite = unittest.TestLoader().loadTestsFromTestCase(UcsDBTest)
+    unittest.TextTestRunner(verbosity=2).run(suite)

=== added file 'quantum/plugins/cisco/db/l2network_db.py'
--- quantum/plugins/cisco/db/l2network_db.py	1970-01-01 00:00:00 +0000
+++ quantum/plugins/cisco/db/l2network_db.py	2011-08-01 03:39:28 +0000
@@ -0,0 +1,239 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011, Cisco Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+# @author: Rohit Agarwalla, Cisco Systems, Inc.
+
+from sqlalchemy.orm import exc
+
+import l2network_models
+import quantum.db.api as db
+import quantum.db.models as models
+
+
+def get_all_vlan_bindings():
+    """Lists all the vlan to network associations"""
+    session = db.get_session()
+    try:
+        bindings = session.query(l2network_models.VlanBinding).\
+          all()
+        return bindings
+    except exc.NoResultFound:
+        return []
+
+
+def get_vlan_binding(netid):
+    """Lists the vlan given a network_id"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.VlanBinding).\
+          filter_by(network_id=netid).\
+          one()
+        return binding
+    except exc.NoResultFound:
+        raise Exception("No network found with net-id = %s" % network_id)
+
+
+def add_vlan_binding(vlanid, vlanname, netid):
+    """Adds a vlan to network association"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.VlanBinding).\
+          filter_by(vlan_id=vlanid).\
+          one()
+        raise Exception("Vlan with id \"%s\" already exists" % vlanid)
+    except exc.NoResultFound:
+        binding = l2network_models.VlanBinding(vlanid, vlanname, netid)
+        session.add(binding)
+        session.flush()
+        return binding
+
+
+def remove_vlan_binding(netid):
+    """Removes a vlan to network association"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.VlanBinding).\
+          filter_by(network_id=netid).\
+          one()
+        session.delete(binding)
+        session.flush()
+        return binding
+    except exc.NoResultFound:
+            pass
+
+
+def update_vlan_binding(netid, newvlanid=None, newvlanname=None):
+    """Updates a vlan to network association"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.VlanBinding).\
+          filter_by(network_id=netid).\
+          one()
+        if newvlanid:
+            binding.vlan_id = newvlanid
+        if newvlanname:
+            binding.vlan_name = newvlanname
+        session.merge(binding)
+        session.flush()
+        return binding
+    except exc.NoResultFound:
+        raise Exception("No vlan binding found with network_id = %s" % netid)
+
+
+def get_all_portprofiles():
+    """Lists all the port profiles"""
+    session = db.get_session()
+    try:
+        pps = session.query(l2network_models.PortProfile).\
+          all()
+        return pps
+    except exc.NoResultFound:
+        return []
+
+
+def get_portprofile(ppid):
+    """Lists a port profile"""
+    session = db.get_session()
+    try:
+        pp = session.query(l2network_models.PortProfile).\
+          filter_by(uuid=ppid).\
+          one()
+        return pp
+    except exc.NoResultFound:
+        raise Exception("No portprofile found with id = %s" % ppid)
+
+
+def add_portprofile(ppname, vlanid, qos):
+    """Adds a port profile"""
+    session = db.get_session()
+    try:
+        pp = session.query(l2network_models.PortProfile).\
+          filter_by(name=ppname).\
+          one()
+        raise Exception("Port profile with name %s already exists" % ppname)
+    except exc.NoResultFound:
+        pp = l2network_models.PortProfile(ppname, vlanid, qos)
+        session.add(pp)
+        session.flush()
+        return pp
+
+
+def remove_portprofile(ppid):
+    """Removes a port profile"""
+    session = db.get_session()
+    try:
+        pp = session.query(l2network_models.PortProfile).\
+          filter_by(uuid=ppid).\
+          one()
+        session.delete(pp)
+        session.flush()
+        return pp
+    except exc.NoResultFound:
+            pass
+
+
+def update_portprofile(ppid, newppname=None, newvlanid=None, newqos=None):
+    """Updates port profile"""
+    session = db.get_session()
+    try:
+        pp = session.query(l2network_models.PortProfile).\
+          filter_by(uuid=ppid).\
+          one()
+        if newppname:
+            pp.name = newppname
+        if newvlanid:
+            pp.vlan_id = newvlanid
+        if newqos:
+            pp.qos = newqos
+        session.merge(pp)
+        session.flush()
+        return pp
+    except exc.NoResultFound:
+        raise Exception("No port profile with id = %s" % ppid)
+
+
+def get_all_pp_bindings():
+    """Lists all the port profiles"""
+    session = db.get_session()
+    try:
+        bindings = session.query(l2network_models.PortProfileBinding).\
+          all()
+        return bindings
+    except exc.NoResultFound:
+        return []
+
+
+def get_pp_binding(ppid):
+    """Lists a port profile binding"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.PortProfileBinding).\
+          filter_by(portprofile_id=ppid).\
+          one()
+        return binding
+    except exc.NoResultFound:
+        raise Exception("No portprofile binding found with id = %s" % ppid)
+
+
+def add_pp_binding(tenantid, networkid, ppid, default):
+    """Adds a port profile binding"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.PortProfileBinding).\
+          filter_by(portprofile_id=ppid).\
+          one()
+        raise Exception("Port profile binding with id \"%s\" already \
+                                                         exists" % ppid)
+    except exc.NoResultFound:
+        binding = l2network_models.PortProfileBinding(tenantid, networkid, \
+                                                            ppid, default)
+        session.add(binding)
+        session.flush()
+        return binding
+
+
+def remove_pp_binding(ppid):
+    """Removes a port profile binding"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.PortProfileBinding).\
+          filter_by(portprofile_id=ppid).\
+          one()
+        session.delete(binding)
+        session.flush()
+        return binding
+    except exc.NoResultFound:
+            pass
+
+
+def update_pp_binding(ppid, newtenantid=None, newnetworkid=None, \
+                                                    newdefault=None):
+    """Updates port profile binding"""
+    session = db.get_session()
+    try:
+        binding = session.query(l2network_models.PortProfileBinding).\
+          filter_by(portprofile_id=ppid).\
+          one()
+        if newtenantid:
+            binding.tenant_id = newtenantid
+        if newnetworkid:
+            binding.network_id = newnetworkid
+        if newdefault:
+            binding.default = newdefault
+        session.merge(binding)
+        session.flush()
+        return binding
+    except exc.NoResultFound:
+        raise Exception("No port profile binding with id = %s" % ppid)

=== added file 'quantum/plugins/cisco/db/l2network_models.py'
--- quantum/plugins/cisco/db/l2network_models.py	1970-01-01 00:00:00 +0000
+++ quantum/plugins/cisco/db/l2network_models.py	2011-08-01 03:39:28 +0000
@@ -0,0 +1,86 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011, Cisco Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+# @author: Rohit Agarwalla, Cisco Systems, Inc.
+
+import uuid
+
+from sqlalchemy import Column, Integer, String, ForeignKey, Boolean
+from sqlalchemy.orm import relation
+
+from quantum.db.models import BASE
+
+
+class VlanBinding(BASE):
+    """Represents a binding of vlan_id to network_id"""
+    __tablename__ = 'vlan_bindings'
+
+    vlan_id = Column(Integer, primary_key=True)
+    vlan_name = Column(String(255))
+    network_id = Column(String(255), nullable=False)
+    #foreign key to networks.uuid
+
+    def __init__(self, vlan_id, vlan_name, network_id):
+        self.vlan_id = vlan_id
+        self.vlan_name = vlan_name
+        self.network_id = network_id
+
+    def __repr__(self):
+        return "<VlanBinding(%d,%s,%s)>" % \
+          (self.vlan_id, self.vlan_name, self.network_id)
+
+
+class PortProfile(BASE):
+    """Represents Cisco plugin level PortProfile for a network"""
+    __tablename__ = 'portprofiles'
+
+    uuid = Column(String(255), primary_key=True)
+    name = Column(String(255))
+    vlan_id = Column(Integer)
+    qos = Column(String(255))
+
+    def __init__(self, name, vlan_id, qos=None):
+            self.uuid = uuid.uuid4()
+            self.name = name
+            self.vlan_id = vlan_id
+            self.qos = qos
+
+    def __repr__(self):
+        return "<PortProfile(%s,%s,%d,%s)>" % \
+          (self.uuid, self.name, self.vlan_id, self.qos)
+
+
+class PortProfileBinding(BASE):
+    """Represents PortProfile binding to tenant and network"""
+    __tablename__ = 'portprofile_bindings'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    tenant_id = Column(String(255))
+
+    network_id = Column(String(255), nullable=False)
+    #foreign key to networks.uuid
+    portprofile_id = Column(String(255), nullable=False)
+    #foreign key to portprofiles.uuid
+    default = Column(Boolean)
+
+    def __init__(self, tenant_id, network_id, portprofile_id, default):
+        self.tenant_id = tenant_id
+        self.network_id = network_id
+        self.portprofile_id = portprofile_id
+        self.default = default
+
+    def __repr__(self):
+        return "<PortProfile Binding(%s,%s,%s,%s)>" % \
+          (self.tenant_id, self.network_id, self.portprofile_id, self.default)

=== added file 'quantum/plugins/cisco/db/ucs_db.py'
--- quantum/plugins/cisco/db/ucs_db.py	1970-01-01 00:00:00 +0000
+++ quantum/plugins/cisco/db/ucs_db.py	2011-08-01 03:39:28 +0000
@@ -0,0 +1,314 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011, Cisco Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+# @author: Rohit Agarwalla, Cisco Systems, Inc.
+
+from sqlalchemy.orm import exc
+
+import quantum.db.api as db
+import ucs_models
+
+
+def get_all_ucsmbinding():
+    """Lists all the ucsm bindings"""
+    session = db.get_session()
+    try:
+        bindings = session.query(ucs_models.UcsmBinding).\
+          all()
+        return bindings
+    except exc.NoResultFound:
+        return []
+
+
+def get_ucsmbinding(ucsm_ip):
+    """Lists a ucsm binding"""
+    session = db.get_session()
+    try:
+        binding = session.query(ucs_models.UcsmBinding).\
+          filter_by(ucsm_ip=ucsm_ip).\
+          one()
+        return binding
+    except exc.NoResultFound:
+        raise Exception("No binding found with ip = %s" % ucsm_ip)
+
+
+def add_ucsmbinding(ucsm_ip, network_id):
+    """Adds a ucsm binding"""
+    session = db.get_session()
+    try:
+        ip = session.query(ucs_models.UcsmBinding).\
+          filter_by(ucsm_ip=ucsm_ip).\
+          one()
+        raise Exception("Binding with ucsm ip \"%s\" already exists" % ucsm_ip)
+    except exc.NoResultFound:
+        binding = ucs_models.UcsmBinding(ucsm_ip, network_id)
+        session.add(binding)
+        session.flush()
+        return binding
+
+
+def remove_ucsmbinding(ucsm_ip):
+    """Removes a ucsm binding"""
+    session = db.get_session()
+    try:
+        binding = session.query(ucs_models.UcsmBinding).\
+          filter_by(ucsm_ip=ucsm_ip).\
+          one()
+        session.delete(binding)
+        session.flush()
+        return binding
+    except exc.NoResultFound:
+            pass
+
+
+def update_ucsmbinding(ucsm_ip, new_network_id):
+    """Updates ucsm binding"""
+    session = db.get_session()
+    try:
+        binding = session.query(ucs_models.UcsmBinding).\
+          filter_by(ucsm_ip=ucsm_ip).\
+          one()
+        if new_network_id:
+            binding.network_id = new_network_id
+        session.merge(binding)
+        session.flush()
+        return binding
+    except exc.NoResultFound:
+        raise Exception("No binding with ip = %s" % ucsm_ip)
+
+
+def get_all_dynamicvnics():
+    """Lists all the dynamic vnics"""
+    session = db.get_session()
+    try:
+        vnics = session.query(ucs_models.DynamicVnic).\
+          all()
+        return vnics
+    except exc.NoResultFound:
+        return []
+
+
+def get_dynamicvnic(vnic_id):
+    """Lists a dynamic vnic"""
+    session = db.get_session()
+    try:
+        vnic = session.query(ucs_models.DynamicVnic).\
+          filter_by(uuid=vnic_id).\
+          one()
+        return vnic
+    except exc.NoResultFound:
+        raise Exception("No dynamic vnic found with id = %s" % vnic_id)
+
+
+def add_dynamicvnic(device_name, blade_id):
+    """Adds a dynamic vnic"""
+    session = db.get_session()
+    try:
+        name = session.query(ucs_models.DynamicVnic).\
+          filter_by(device_name=device_name).\
+          one()
+        raise Exception("Dynamic vnic with device name %s already exists" % \
+                                                                device_name)
+    except exc.NoResultFound:
+        vnic = ucs_models.DynamicVnic(device_name, blade_id)
+        session.add(vnic)
+        session.flush()
+        return vnic
+
+
+def remove_dynamicvnic(vnic_id):
+    """Removes a dynamic vnic"""
+    session = db.get_session()
+    try:
+        vnic = session.query(ucs_models.DynamicVnic).\
+          filter_by(uuid=vnic_id).\
+          one()
+        session.delete(vnic)
+        session.flush()
+        return vnic
+    except exc.NoResultFound:
+            pass
+
+
+def update_dynamicvnic(vnic_id, new_device_name=None, new_blade_id=None):
+    """Updates dynamic vnic"""
+    session = db.get_session()
+    try:
+        vnic = session.query(ucs_models.DynamicVnic).\
+          filter_by(uuid=vnic_id).\
+          one()
+        if new_device_name:
+            vnic.device_name = new_device_name
+        if new_blade_id:
+            vnic.blade_id = new_blade_id
+        session.merge(vnic)
+        session.flush()
+        return vnic
+    except exc.NoResultFound:
+        raise Exception("No dynamic vnic with id = %s" % vnic_id)
+
+
+def get_all_blades():
+    """Lists all the blades details"""
+    session = db.get_session()
+    try:
+        blades = session.query(ucs_models.UcsBlade).\
+          all()
+        return blades
+    except exc.NoResultFound:
+        return []
+
+
+def get_blade(blade_id):
+    """Lists a blade details"""
+    session = db.get_session()
+    try:
+        blade = session.query(ucs_models.UcsBlade).\
+          filter_by(uuid=blade_id).\
+          one()
+        return blade
+    except exc.NoResultFound:
+        raise Exception("No blade found with id = %s" % blade_id)
+
+
+def add_blade(mgmt_ip, mac_addr, chassis_id, ucsm_ip):
+    """Adds a blade"""
+    session = db.get_session()
+    try:
+        ip = session.query(ucs_models.UcsBlade).\
+          filter_by(mgmt_ip=mgmt_ip).\
+          one()
+        raise Exception("Blade with ip \"%s\" already exists" % mgmt_ip)
+    except exc.NoResultFound:
+        blade = ucs_models.UcsBlade(mgmt_ip, mac_addr, chassis_id, ucsm_ip)
+        session.add(blade)
+        session.flush()
+        return blade
+
+
+def remove_blade(blade_id):
+    """Removes a blade"""
+    session = db.get_session()
+    try:
+        blade = session.query(ucs_models.UcsBlade).\
+          filter_by(uuid=blade_id).\
+          one()
+        session.delete(blade)
+        session.flush()
+        return blade
+    except exc.NoResultFound:
+            pass
+
+
+def update_blade(blade_id, new_mgmt_ip=None, new_mac_addr=None, \
+                         new_chassis_id=None, new_ucsm_ip=None):
+    """Updates details of a blade"""
+    session = db.get_session()
+    try:
+        blade = session.query(ucs_models.UcsBlade).\
+          filter_by(uuid=blade_id).\
+          one()
+        if new_mgmt_ip:
+            blade.mgmt_ip = new_mgmt_ip
+        if new_mac_addr:
+            blade.mac_addr = new_mac_addr
+        if new_chassis_id:
+            blade.chassis_id = new_chassis_id
+        if new_ucsm_ip:
+            blade.ucsm_ip = new_ucsm_ip
+        session.merge(blade)
+        session.flush()
+        return blade
+    except exc.NoResultFound:
+        raise Exception("No blade with id = %s" % blade_id)
+
+
+def get_all_portbindings():
+    """Lists all the port bindings"""
+    session = db.get_session()
+    try:
+        port_bindings = session.query(ucs_models.PortBinding).\
+          all()
+        return port_bindings
+    except exc.NoResultFound:
+        return []
+
+
+def get_portbinding(port_id):
+    """Lists a port binding"""
+    session = db.get_session()
+    try:
+        port_binding = session.query(ucs_models.PortBinding).\
+          filter_by(port_id=port_id).\
+          one()
+        return port_binding
+    except exc.NoResultFound:
+        raise Exception("No port binding found with port id = %s" % port_id)
+
+
+def add_portbinding(port_id, dynamic_vnic_id, portprofile_name, \
+                                        vlan_name, vlan_id, qos):
+    """Adds a port binding"""
+    session = db.get_session()
+    try:
+        port_binding = session.query(ucs_models.PortBinding).\
+          filter_by(port_id=port_id).\
+          one()
+        raise Exception("Port Binding with portid %s already exists" % port_id)
+    except exc.NoResultFound:
+        port_binding = ucs_models.PortBinding(port_id, dynamic_vnic_id, \
+                                     portprofile_name, vlan_name, vlan_id, qos)
+        session.add(port_binding)
+        session.flush()
+        return port_binding
+
+
+def remove_portbinding(port_id):
+    """Removes a port binding"""
+    session = db.get_session()
+    try:
+        port_binding = session.query(ucs_models.PortBinding).\
+          filter_by(port_id=port_id).\
+          one()
+        session.delete(port_binding)
+        session.flush()
+        return port_binding
+    except exc.NoResultFound:
+            pass
+
+
+def update_portbinding(port_id, dynamic_vnic_id=None, portprofile_name=None, \
+                       vlan_name=None, vlan_id=None, qos=None):
+    """Updates port binding"""
+    session = db.get_session()
+    try:
+        port_binding = session.query(ucs_models.PortBinding).\
+          filter_by(port_id=port_id).\
+          one()
+        if dynamic_vnic_id:
+            port_binding.dynamic_vnic_id = dynamic_vnic_id
+        if portprofile_name:
+            port_binding.portprofile_name = portprofile_name
+        if vlan_name:
+            port_binding.vlan_name = vlan_name
+        if vlan_name:
+            port_binding.vlan_id = vlan_id
+        if qos:
+            port_binding.qos = qos
+        session.merge(port_binding)
+        session.flush()
+        return port_binding
+    except exc.NoResultFound:
+        raise Exception("No port binding with port id = %s" % port_id)

=== added file 'quantum/plugins/cisco/db/ucs_models.py'
--- quantum/plugins/cisco/db/ucs_models.py	1970-01-01 00:00:00 +0000
+++ quantum/plugins/cisco/db/ucs_models.py	2011-08-01 03:39:28 +0000
@@ -0,0 +1,113 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011, Cisco Systems, Inc.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+# @author: Rohit Agarwalla, Cisco Systems, Inc.
+
+import uuid
+
+from sqlalchemy import Column, Integer, String, ForeignKey, Boolean
+from sqlalchemy.orm import relation
+
+from quantum.db.models import BASE
+
+
+class UcsmBinding(BASE):
+    """Represents a binding of ucsm to network_id"""
+    __tablename__ = 'ucsm_bindings'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    ucsm_ip = Column(String(255))
+    network_id = Column(String(255), nullable=False)
+    #foreign key to networks.uuid
+
+    def __init__(self, ucsm_ip, network_id):
+        self.ucsm_ip = ucsm_ip
+        self.network_id = network_id
+
+    def __repr__(self):
+        return "<UcsmBinding(%s,%s)>" % \
+          (self.ucsm_ip, self.network_id)
+
+
+class DynamicVnic(BASE):
+    """Represents Cisco UCS Dynamic Vnics"""
+    __tablename__ = 'dynamic_vnics'
+
+    uuid = Column(String(255), primary_key=True)
+    device_name = Column(String(255))
+    blade_id = Column(String(255), ForeignKey("ucs_blades.uuid"), \
+                                                    nullable=False)
+
+    def __init__(self, device_name, blade_id):
+            self.uuid = uuid.uuid4()
+            self.device_name = device_name
+            self.blade_id = blade_id
+
+    def __repr__(self):
+        return "<Dyanmic Vnic(%s,%s,%s)>" % \
+          (self.uuid, self.device_name, self.blade_id)
+
+
+class UcsBlade(BASE):
+    """Represents details of ucs blades"""
+    __tablename__ = 'ucs_blades'
+
+    uuid = Column(String(255), primary_key=True)
+    mgmt_ip = Column(String(255))
+    mac_addr = Column(String(255))
+    chassis_id = Column(String(255))
+    ucsm_ip = Column(String(255))
+    dynamic_vnics = relation(DynamicVnic, order_by=DynamicVnic.uuid, \
+                                                      backref="blade")
+
+    def __init__(self, mgmt_ip, mac_addr, chassis_id, ucsm_ip):
+        self.uuid = uuid.uuid4()
+        self.mgmt_ip = mgmt_ip
+        self.mac_addr = mac_addr
+        self.chassis_id = chassis_id
+        self.ucsm_ip = ucsm_ip
+
+    def __repr__(self):
+        return "<UcsBlades (%s,%s,%s,%s,%s)>" % \
+       (self.uuid, self.mgmt_ip, self.mac_addr, self.chassis_id, self.ucsm_ip)
+
+
+class PortBinding(BASE):
+    """Represents Port binding to device interface"""
+    __tablename__ = 'port_bindings'
+
+    id = Column(Integer, primary_key=True, autoincrement=True)
+    port_id = Column(String(255), nullable=False)
+    #foreign key to ports.uuid
+    dynamic_vnic_id = Column(String(255), nullable=False)
+    #foreign key to dynamic_vnics.uuid
+    portprofile_name = Column(String(255))
+    vlan_name = Column(String(255))
+    vlan_id = Column(Integer)
+    qos = Column(String(255))
+
+    def __init__(self, port_id, dynamic_vnic_id, portprofile_name, vlan_name, \
+                                                                vlan_id, qos):
+        self.port_id = port_id
+        self.dynamic_vnic_id = dynamic_vnic_id
+        self.portprofile_name = portprofile_name
+        self.vlan_name = vlan_name
+        self.vlan_id = vlan_id
+        self.qos = qos
+
+    def __repr__(self):
+        return "<PortProfile Binding(%s,%s,%s,%s,%s,%s)>" % \
+          (self.port_id, self.dynamic_vnic_id, self.portprofile_name, \
+                                self.vlan_name, self.vlan_id, self.qos)