Merge lp:~midokura/nova/network-service into lp:~ntt-pf-lab/nova/network-service

[Ryu Ishimoto]

Added EC2 floating IP API support.

Added EC2 floating IP API support.

=== added file 'bin/nova-net-flat-vlan-manage'
--- bin/nova-net-flat-vlan-manage	1970-01-01 00:00:00 +0000
+++ bin/nova-net-flat-vlan-manage	2011-04-06 17:14:53 +0000
@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Midokura KK
+# All Rights Reserved.
+#
+#    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.
+
+# Interactive shell based on Django:
+#
+# Copyright (c) 2005, the Lawrence Journal-World
+# All rights reserved.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+#
+#     1. Redistributions of source code must retain the above copyright notice,
+#        this list of conditions and the following disclaimer.
+#
+#     2. Redistributions in binary form must reproduce the above copyright
+#        notice, this list of conditions and the following disclaimer in the
+#        documentation and/or other materials provided with the distribution.
+#
+#     3. Neither the name of Django nor the names of its contributors may be
+#        used to endorse or promote products derived from this software without
+#        specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+"""
+  CLI interface for nova flat vlan network management.
+"""
+
+import gettext
+import os
+import sys
+
+import IPy
+
+# If ../nova/__init__.py exists, add ../ to Python search path, so that
+# it will override what happens to be installed in /usr/(local/)lib/python...
+possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
+                                   os.pardir,
+                                   os.pardir))
+if os.path.exists(os.path.join(possible_topdir, 'nova', '__init__.py')):
+    sys.path.insert(0, possible_topdir)
+
+gettext.install('nova', unicode=1)
+
+from nova import context
+from nova import db as nova_db
+from nova import exception
+from nova import flags as nova_flags
+from nova import log as logging
+from nova import utils
+
+from nova.network.flat_vlan import db
+
+NOVA_FLAGS = nova_flags.FLAGS
+
+class FloatingIpCommands(object):
+    """Class for managing floating ip."""
+
+    def create(self, host, range):
+        """Creates floating ips for host by range
+        arguments: host ip_range"""
+        for address in IPy.IP(range):
+            db.floating_ip_create(context.get_admin_context(),
+                                  {'address': str(address),
+                                   'host': host})
+
+    def delete(self, ip_range):
+        """Deletes floating ips by range
+        arguments: range"""
+        for address in IPy.IP(ip_range):
+            db.floating_ip_destroy(context.get_admin_context(),
+                                   str(address))
+
+    def list(self, host=None):
+        """Lists all floating ips (optionally by host)
+        arguments: [host]"""
+        ctxt = context.get_admin_context()
+        if host == None:
+            floating_ips = db.floating_ip_get_all(ctxt)
+        else:
+            floating_ips = db.floating_ip_get_all_by_host(ctxt, host)
+        for floating_ip in floating_ips:
+            instance_id = None
+            fixed_ip = floating_ip['fixed_ip']
+            if fixed_ip and fixed_ip['ethernet_card_id']:
+                vnic_id = fixed_ip['ethernet_card_id']
+                instance = nova_db.instance_get_by_virtual_nic(ctxt,
+                                                               vnic_id)
+                instance_id = instance['ec2_id']
+            print "%s\t%s\t%s" % (floating_ip['host'],
+                                  floating_ip['address'],
+                                  instance_id)
+
+
+CATEGORIES = [
+    ('floating', FloatingIpCommands)]
+
+def lazy_match(name, key_value_tuples):
+    """Finds all objects that have a key that case insensitively contains
+    [name] key_value_tuples is a list of tuples of the form (key, value)
+    returns a list of tuples of the form (key, value)"""
+    result = []
+    for (k, v) in key_value_tuples:
+        if k.lower().find(name.lower()) == 0:
+            result.append((k, v))
+    if len(result) == 0:
+        print "%s does not match any options:" % name
+        for k, _v in key_value_tuples:
+            print "\t%s" % k
+        sys.exit(2)
+    if len(result) > 1:
+        print "%s matched multiple options:" % name
+        for k, _v in result:
+            print "\t%s" % k
+        sys.exit(2)
+    return result
+
+def methods_of(obj):
+    """Get all callable methods of an object that don't start with underscore
+    returns a list of tuples of the form (method_name, method)"""
+    result = []
+    for i in dir(obj):
+        if callable(getattr(obj, i)) and not i.startswith('_'):
+            result.append((i, getattr(obj, i)))
+    return result
+
+
+def main():
+    """Parse options and call the appropriate class/method."""
+    utils.default_flagfile()
+    argv = NOVA_FLAGS(sys.argv)
+    logging.setup()
+
+    script_name = argv.pop(0)
+    if len(argv) < 1:
+        print script_name + " category action [<args>]"
+        print "Available categories:"
+        for k, _ in CATEGORIES:
+            print "\t%s" % k
+        sys.exit(2)
+    category = argv.pop(0)
+    matches = lazy_match(category, CATEGORIES)
+    # instantiate the command group object
+    category, fn = matches[0]
+    command_object = fn()
+    actions = methods_of(command_object)
+    if len(argv) < 1:
+        print script_name + " category action [<args>]"
+        print "Available actions for %s category:" % category
+        for k, _v in actions:
+            print "\t%s" % k
+        sys.exit(2)
+    action = argv.pop(0)
+    matches = lazy_match(action, actions)
+    action, fn = matches[0]
+    # call the action with the remaining arguments
+    try:
+        fn(*argv)
+        sys.exit(0)
+    except TypeError:
+        print "Possible wrong number of arguments supplied"
+        print "%s %s: %s" % (category, action, fn.__doc__)
+        raise
+
+if __name__ == '__main__':
+    main()
 
=== modified file 'nova/api/ec2/cloud.py'
--- nova/api/ec2/cloud.py	2011-03-24 20:20:15 +0000
+++ nova/api/ec2/cloud.py	2011-04-06 17:14:53 +0000
@@ -36,7 +36,8 @@
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import network
+from nova.network import service as net_service
+from nova import quota
 from nova import utils
 from nova import volume
 from nova.api.ec2 import ec2utils
@@ -82,10 +83,9 @@
 """
     def __init__(self):
         self.image_service = s3.S3ImageService()
-        self.network_api = network.API()
         self.volume_api = volume.API()
         self.compute_api = compute.API(
-                network_api=self.network_api,
+                network_api=None,
                 volume_api=self.volume_api,
                 hostname_factory=ec2utils.id_to_ec2_id)
         self.setup()
@@ -767,26 +767,48 @@
 
     def allocate_address(self, context, **kwargs):
         LOG.audit(_("Allocate address"), context=context)
-        public_ip = self.network_api.allocate_floating_ip(context)
+        _, net_factory = net_service.get_service_factory(context,
+                                                         context.project_id)
+        net_api_service = net_factory.get_api_service()
+        ip_quota = quota.get_quota(context, context.project_id)['floating_ips']
+        try:
+            public_ip = net_api_service.allocate_address(context,
+                                                         context.project_id,
+                                                         ip_quota)
+        except quota.QuotaError, ex:
+            LOG.warn(_("Quota exceeded for %s, tried to allocate "
+                           "address"),
+                         context.project_id)
+            raise ex
+
         return {'addressSet': [{'publicIp': public_ip}]}
 
     def release_address(self, context, public_ip, **kwargs):
         LOG.audit(_("Release address %s"), public_ip, context=context)
-        self.network_api.release_floating_ip(context, address=public_ip)
+        _, net_factory = net_service.get_service_factory(context,
+                                                         context.project_id)
+        net_api_service = net_factory.get_api_service()
+        
+        net_api_service.deallocate_address(context, public_ip)
         return {'releaseResponse': ["Address released."]}
 
     def associate_address(self, context, instance_id, public_ip, **kwargs):
         LOG.audit(_("Associate address %(public_ip)s to"
                 " instance %(instance_id)s") % locals(), context=context)
         instance_id = ec2utils.ec2_id_to_id(instance_id)
-        self.compute_api.associate_floating_ip(context,
-                                               instance_id=instance_id,
-                                               address=public_ip)
+        vnic_ids = db.virtual_nics_get_by_instance(context, instance_id)
+        _, net_factory = net_service.get_service_factory(context,
+                                                         context.project_id)
+        net_api_service = net_factory.get_api_service()
+        net_api_service.associate_address(context, vnic_ids[0], public_ip)
         return {'associateResponse': ["Address associated."]}
 
     def disassociate_address(self, context, public_ip, **kwargs):
         LOG.audit(_("Disassociate address %s"), public_ip, context=context)
-        self.network_api.disassociate_floating_ip(context, address=public_ip)
+        _, net_factory = net_service.get_service_factory(context,
+                                                         context.project_id)
+        net_api_service = net_factory.get_api_service()
+        net_api_service.disassociate_address(context, public_ip)
         return {'disassociateResponse': ["Address disassociated."]}
 
     def run_instances(self, context, **kwargs):
 
=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-03-30 08:30:38 +0000
+++ nova/compute/api.py	2011-04-06 17:14:53 +0000
@@ -681,12 +681,6 @@
                            "volume_id": volume_id}})
         return instance
 
-    def associate_floating_ip(self, context, instance_id, address):
-        instance = self.get(context, instance_id)
-        self.network_api.associate_floating_ip(context,
-                                               floating_ip=address,
-                                               fixed_ip=instance['fixed_ip'])
-
     def get_instance_metadata(self, context, instance_id):
         """Get all metadata associated with an instance."""
         rv = self.db.instance_metadata_get(context, instance_id)
 
=== modified file 'nova/network/flat_vlan/api/__init__.py'
--- nova/network/flat_vlan/api/__init__.py	2011-03-31 07:15:23 +0000
+++ nova/network/flat_vlan/api/__init__.py	2011-04-06 17:14:53 +0000
@@ -16,19 +16,26 @@
 #    under the License.
 from zope import interface
 
+from nova import exception
+from nova import quota
+from nova import rpc
 from nova.network import service
+from nova.network.flat_vlan import common
+from nova.network.flat_vlan import flags
 from nova.network.flat_vlan import manager
-from nova.network.flat_vlan.db import api as db_api
+from nova.network.flat_vlan import db
+
+FLAGS = flags.FlagAccessor()
 
 class NetworkApiService(object):
     """Network API Service for this plugin."""
-    
+
     interface.implements(service.INetworkApiService)
 
     def create_vnic(self, context):
         """Generic API to retrieve the default VNIC ID.
         For flat simple network, create a new vNIC and return its ID.
-        
+
         Args:
            context: Nova context object needed to access the DB.
 
@@ -38,20 +45,99 @@
         # Create a new VNIC
         vnic = manager.ethernet_card_create_with_random_mac(context)
         return vnic.id
-    
+
     def get_project_vpn_address_and_port(self, context, project_id):
         """Generic API to get network for a given project.
-        
+
         Args:
             context: Nova context object needed to access the DB.
             project_id: project to get the VPN IP and port for.
-           
+
         Returns:
            A tuple of VPN IP address and port number.
         """
-        network = db_api.network_get_by_project(context, project_id)
+        network = db.network_get_by_project(context, project_id)
         if network:
             return (network['vpn_public_address'], network['vpn_public_port'])
         else:
             return (None, None)
 
+    def allocate_address(self, context, project_id, ip_quota):
+        """Gets the number of floating IPs associated with a project.
+
+        Args:
+            context: Nova context object needed to access the DB.
+            project_id: Project to allocate the address from.
+            ip_quota: Quota for IP addresses.
+
+        Returns:
+            An IP address.
+
+        Raises:
+            quota.QuotaError: Over the quota limit.
+        """
+        used_floating_ips = db.floating_ip_count_by_project(context,
+                                project_id)
+        allowed_floating_ips = min(1, ip_quota - used_floating_ips)
+        if allowed_floating_ips < 1:
+            raise quota.QuotaError(_("Quota exceeeded for %s, tried to allocate"
+                           " address"), project_id)
+
+        # Let the network service handle this because the DB update requires the 
+        # network service host name.
+        host = rpc.call(context,
+                        FLAGS.net_flat_vlan_network_topic,
+                        {"method": "get_host"})
+
+        ip = db.floating_ip_allocate_address(context, host, project_id)
+        return ip.address
+
+    def deallocate_address(self, context, floating_address):
+        """Deallocates the public IP address by removing it from any 
+        project.
+        
+        Args:
+           context: nova context object needed to access the DB.
+           address: Public IP address to deallocate.
+        """
+        db.floating_ip_deallocate(context, floating_address)
+
+    def associate_address(self, context, vnic_id, floating_address):
+        """Associates a floating address to the fixed IP address of the vnic.
+        
+        Args:
+           context: Nova context object
+           vnic_id: virtual NIC ID
+           floating_address: public IP address to assign to the VNIC.
+        """
+        fixed_ip = db.fixed_ip_get_by_ethernet_card(context, vnic_id)
+        floating_ip = db.floating_ip_get_by_address(context, floating_address)
+        db.floating_ip_fixed_ip_associate(context, floating_ip['address'], 
+                                          fixed_ip['address'])
+        
+        host = fixed_ip['network']['host']
+        rpc.cast(context,
+                 common.queue_get_for(FLAGS.net_flat_vlan_network_topic, 
+                                      host),
+                 {"method": "activate_public_ip",
+                  "args": {"floating_address": floating_ip['address'],
+                           "fixed_address": fixed_ip['address']}})
+                                               
+    def disassociate_address(self, context, floating_address):
+        """Diassociates public IP.
+        
+        Args:
+           context: Nova context object
+           floating_address: public IP address
+        """
+        floating_ip = db.floating_ip_get_by_address(context, floating_address)
+        if not floating_ip.get('fixed_ip'):
+            raise exception.ApiError('Address is not associated.')
+        fixed_ip = db.floating_ip_disassociate(context, floating_address)
+        host = fixed_ip['network']['host']
+        rpc.cast(context,
+                 common.queue_get_for(FLAGS.net_flat_vlan_network_topic, 
+                                      host),
+                 {"method": "deactivate_public_ip",
+                  "args": {"floating_address": floating_ip['address'],
+                           "fixed_address": fixed_ip['address']}})       
 
=== modified file 'nova/network/flat_vlan/common.py'
--- nova/network/flat_vlan/common.py	2011-03-31 09:36:57 +0000
+++ nova/network/flat_vlan/common.py	2011-04-06 17:14:53 +0000
@@ -44,3 +44,15 @@
     """
     net = IPy.IP(cidr)
     return str(net.net()), str(net.netmask())
+
+def queue_get_for(topic, physical_node_id):
+    """Gets the queue name for RPC.
+    
+    Args:
+       topic: Topic to listen to
+       physical_node_id: Node ID to listen to.
+       
+    Returns:
+      The queue name to send the RPC to.
+    """
+    return "%s.%s" % (topic, physical_node_id)
 \ No newline at end of file
 
=== modified file 'nova/network/flat_vlan/compute.py'
--- nova/network/flat_vlan/compute.py	2011-04-04 09:52:18 +0000
+++ nova/network/flat_vlan/compute.py	2011-04-06 17:14:53 +0000
@@ -26,18 +26,6 @@
 
 FLAGS = flags.FlagAccessor()
 
-def _queue_get_for(topic, physical_node_id):
-    """Gets the queue name for RPC.
-    
-    Args:
-       topic: Topic to listen to
-       physical_node_id: Node ID to listen to.
-       
-    Returns:
-      The queue name to send the RPC to.
-    """
-    return "%s.%s" % (topic, physical_node_id)
-
 def _get_network_topic(context, **kwargs):
     """Retrieves the network host for a project on this host
     
@@ -51,8 +39,8 @@
         host = FLAGS.net_flat_vlan_network_host
     else:
         host = _get_network_host(context)
-    return _queue_get_for(FLAGS.net_flat_vlan_network_topic,
-                          host)
+    return common.queue_get_for(FLAGS.net_flat_vlan_network_topic,
+                                host)
 
 def _set_network_host(context, network_id):
     """Safely sets the host of the network.
@@ -87,8 +75,8 @@
                                         FLAGS.net_flat_vlan_network_bridge)
     host = network_ref['host']
     if not host:
-        topic = _queue_get_for(FLAGS.net_flat_vlan_network_topic,
-                               FLAGS.net_flat_vlan_network_host)
+        topic = common.queue_get_for(FLAGS.net_flat_vlan_network_topic,
+                                     FLAGS.net_flat_vlan_network_host)
         if FLAGS.net_flat_vlan_network_fake_call:
             return _set_network_host(context, network_ref['id'])
         host = rpc.call(context,
@@ -146,7 +134,8 @@
            vnic_ids: list of VNIC IDs
         """
         for vnic_id in vnic_ids:
-            fixed_ip = vnic_id.get('fixed_ip')
+            vnic_ref = db_api.ethernet_card_get(context, vnic_id)
+            fixed_ip = vnic_ref.get('fixed_ip')
             if not FLAGS.stub_network and fixed_ip:
                 
                 if (FLAGS.net_flat_vlan_use_vlan or 
@@ -156,7 +145,7 @@
                     for floating_ip in floating_ips:
                         address = floating_ip['address']
                     
-                        network_topic = _queue_get_for(context,
+                        network_topic = common.queue_get_for(context,
                                             FLAGS.net_flat_vlan_network_topic,
                                             floating_ip['host'])
                     
 
=== modified file 'nova/network/flat_vlan/db/__init__.py'
--- nova/network/flat_vlan/db/__init__.py	2011-03-31 06:18:29 +0000
+++ nova/network/flat_vlan/db/__init__.py	2011-04-06 17:14:53 +0000
@@ -18,3 +18,4 @@
 DB abstraction for Flat VLAN network service 
 """
 
+from nova.network.flat_vlan.db.api import *
 
=== modified file 'nova/network/flat_vlan/db/api.py'
--- nova/network/flat_vlan/db/api.py	2011-04-02 19:01:17 +0000
+++ nova/network/flat_vlan/db/api.py	2011-04-06 17:14:53 +0000
@@ -19,85 +19,95 @@
 
 The underlying driver is loaded as a :class:`LazyPluggable`.
 """
+from nova import exception
 from nova import utils
+from nova.db.sqlalchemy import api as nova_api
 from nova.network.flat_vlan import flags
 
 FLAGS = flags.FlagAccessor()
 
-IMPL = utils.LazyPluggable(FLAGS.get('net_flat_vlan_db_backend'),
-          sqlalchemy='nova.network.flat_vlan.db.sqlalchemy.api')
+IMPL = utils.LazyPluggable(
+    FLAGS.get('net_flat_vlan_db_backend'),
+    sqlalchemy='nova.network.flat_vlan.db.sqlalchemy.api')
 
 ###################
 
 def ethernet_card_get(context, id):
     """Get ethernet card by id."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         ethernet_card_get(id)
 
 def ethernet_card_create(context, values):
     """Create a new ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         ethernet_card_create(values)
 
 def ethernet_card_get_all(context):
     """Get all ethernet cards."""
-    return IMPL.dao_factory.get_dao(context).\
-        ethernet_card_get_all()
+    can_read_deleted = nova_api.can_read_deleted(context)
+    return IMPL.dao_factory.get_dao().\
+        ethernet_card_get_all(read_deleted=can_read_deleted)
 
 def ethernet_card_update(context, ethernet_card_id, values):
     """Update ethernet card.""" 
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         ethernet_card_update(ethernet_card_id, values)
 
 def ethernet_card_delete(context, ethernet_card_id):
     """Delete ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         ethernet_card_delete(ethernet_card_id)
 
 def network_get(context, id):
     """Get network by id."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_get(id)
     
+@nova_api.require_admin_context
 def network_get_by_ethernet_card(context, ethernet_card_id):
     """Get network by ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_get_by_ethernet_card(ethernet_card_id)
 
+@nova_api.require_admin_context
 def network_get_associated_fixed_ips(context, network_id):
     """Get fixed IPs that are associated with ethernet for a given network."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_get_associated_fixed_ips(network_id)
 
 def host_get_networks(context, host):
     """Get networks for a given host."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         host_get_networks(host)
 
+@nova_api.require_admin_context
 def network_get_by_bridge(context, bridge):    
     """Get a network by bridge or raise if it does not exist."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_get_by_bridge(bridge)
     
+@nova_api.require_admin_context
 def network_get_by_cidr(context, cidr):
     """Get a network by cidr."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_get_by_cidr(cidr)
 
 def network_create(context, values):
     """Create a new network."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_create(values)
 
+@nova_api.require_admin_context
 def network_create_safe(context, values):
     """Create a new network.  Returns None when there is an exception"""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_create_safe(values)
 
 def network_get_all(context):
     """Get all networks."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_get_all()
+    can_read_deleted = nova_api.can_read_deleted(context)
+    return IMPL.dao_factory.get_dao().\
+        network_get_all(read_deleted=can_read_deleted)
 
 def network_get_by_project(context, project_id, associate=True):
     """Return the network associated with the project.
@@ -106,22 +116,25 @@
     network if one is not found, otherwise it returns None.
 
     """
-    return IMPL.dao_factory.get_dao(context).\
+    if associate and not nova_api.is_admin_context(context):
+        raise exception.NotAuthorized()
+    return IMPL.dao_factory.get_dao().\
         network_get_by_project(project_id, associate)
 
 def network_update(context, network_id, values):
     """Update network.""" 
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_update(network_id, values)
 
 def network_delete(context, network_id):
     """Delete network."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_delete(network_id)
 
+@nova_api.require_admin_context
 def network_associate(context, project_id):
     """Associate a free network to a project."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         network_associate(project_id)
 
 def floating_ip_allocate_address(context, host, project_id):
@@ -130,32 +143,38 @@
     Raises if one is not available.
 
     """
-    return IMPL.dao_factory.get_dao(context).\
+    nova_api.authorize_project_context(context, project_id)
+    return IMPL.dao_factory.get_dao().\
         floating_ip_allocate_address(host, project_id)
 
 def floating_ip_create(context, values):
     """Create a floating ip from the values dictionary."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         floating_ip_create(values)
 
 def floating_ip_count_by_project(context, project_id):
     """Count floating ips used by project."""
-    return IMPL.dao_factory.get_dao(context).\
+    nova_api.authorize_project_context(context, project_id)
+    return IMPL.dao_factory.get_dao().\
         floating_ip_count_by_project(project_id)
 
 def floating_ip_deallocate(context, address):
     """Deallocate an floating ip by address"""
-    return IMPL.dao_factory.get_dao(context).\
+    # TODO(devcamcar): How to ensure floating id belongs to user?
+    return IMPL.dao_factory.get_dao().\
         floating_ip_deallocate(address)
 
 def floating_ip_destroy(context, address):
     """Destroy the floating_ip or raise if it does not exist."""
-    return IMPL.dao_factory.get_dao(context).\
+    # TODO(devcamcar): Ensure address belongs to user.
+    return IMPL.dao_factory.get_dao().\
         floating_ip_destroy(address)
 
 def floating_ip_disassociate(context, floating_ip_id):
     """Diassociate the floating_ip."""
-    return IMPL.dao_factory.get_dao(context).\
+    # TODO(devcamcar): Ensure address belongs to user.
+    #                  Does get_floating_ip_by_address handle this?
+    return IMPL.dao_factory.get_dao().\
         floating_ip_disassociate(floating_ip_id)
 
 def floating_ip_disassociate_by_address(context, address):
@@ -164,91 +183,105 @@
     Returns the address of the existing fixed ip.
 
     """
-    return IMPL.dao_factory.get_dao(context).\
+    # TODO(devcamcar): Ensure address belongs to user.
+    #                  Does get_floating_ip_by_address handle this?
+    return IMPL.dao_factory.get_dao().\
         floating_ip_disassociate_by_address(address)
 
 def floating_ip_fixed_ip_associate(context, floating_address, fixed_address):
     """Associate an floating ip to a fixed_ip by address."""
-    return IMPL.dao_factory.get_dao(context).\
+    # TODO(devcamcar): How to ensure floating_id belongs to user?
+    return IMPL.dao_factory.get_dao().\
         floating_ip_fixed_ip_associate(floating_address, fixed_address)
 
+@nova_api.require_admin_context
 def floating_ip_get_all(context):
     """Get all floating ips."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         floating_ip_get_all()
 
+@nova_api.require_admin_context
 def floating_ip_get_all_by_host(context, host):
     """Get all floating ips by host."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         floating_ip_get_all_by_host(host)
 
 def floating_ip_get_all_by_project(context, project_id):
     """Get all floating ips by project."""
-    return IMPL.dao_factory.get_dao(context).\
+    nova_api.authorize_project_context(context, project_id)
+    return IMPL.dao_factory.get_dao().\
         floating_ip_get_all_by_project(project_id)
 
 def floating_ip_get_by_address(context, address):
     """Get a floating ip by address or raise if it doesn't exist."""
-    return IMPL.dao_factory.get_dao(context).\
-        floating_ip_get_by_address(address)
+    # TODO(devcamcar): Ensure the address belongs to user.
+    can_read_deleted = nova_api.can_read_deleted(context)
+    return IMPL.dao_factory.get_dao().\
+        floating_ip_get_by_address(address, read_deleted=can_read_deleted)
 
 def floating_ip_update(context, address, values):
     """Update a floating ip by address or raise if it doesn't exist."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         floating_ip_update(address, values)
 
 def fixed_ip_create(context, values):
     """Creates a fixed IP."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_create(values)
 
 def fixed_ip_get(context, fixed_ip_id):
     """Gets fixed IP with ID."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_get(fixed_ip_id)
 
 def fixed_ip_get_all(context):
     """Gets all the fixed IPs."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_get_all()
 
 def fixed_ip_get_by_address(context, address):
     """Get fixed IP by address."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_get_by_address(address)
+    can_read_deleted = nova_api.can_read_deleted(context)
+    return IMPL.dao_factory.get_dao().\
+        fixed_ip_get_by_address(address, read_deleted=can_read_deleted)
 
 def fixed_ip_get_by_ethernet_card(context, ethernet_card_id):
     """Get IP address by ethernet card id."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_get_by_ethernet_card(ethernet_card_id)
+    can_read_deleted = nova_api.can_read_deleted(context)
+    return IMPL.dao_factory.get_dao().\
+        fixed_ip_get_by_ethernet_card(ethernet_card_id,
+                                      read_deleted=can_read_deleted)
 
+@nova_api.require_admin_context
 def fixed_ip_get_network(context, address):
     """Gets network of an IP address."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_get_network(address)
+    can_read_deleted = nova_api.can_read_deleted(context)
+    return IMPL.dao_factory.get_dao().\
+        fixed_ip_get_network(address, read_deleted=can_read_deleted)
 
 def fixed_ip_update(context, fixed_ip_id, values):
     """Update fixed IP."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_update(fixed_ip_id, values)
 
 def fixed_ip_disassociate(context, fixed_ip_id):
     """Removes reference to ethernet card from IP."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_disassociate(fixed_id_ip)
 
 def fixed_ip_associate(context, fixed_ip_id, ethernet_card_id):
     """Associates an IP address to an ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_associate(fixed_ip_id, ethernet_card_id)
 
+@nova_api.require_admin_context
 def fixed_ip_associate_pool(context, network_id, ethernet_card_id):
     """Associates an IP to an ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_associate_pool(network_id, ethernet_card_id)
 
+@nova_api.require_admin_context
 def fixed_ip_disassociate_all_by_timeout(context, host, time):
     """Disassociates fixed IP by timeout."""
-    return IMPL.dao_factory.get_dao(context).\
+    return IMPL.dao_factory.get_dao().\
         fixed_ip_disassociate_all_by_timeout(host, time)
-   
 \ No newline at end of file
 
=== modified file 'nova/network/flat_vlan/db/sqlalchemy/api.py'
--- nova/network/flat_vlan/db/sqlalchemy/api.py	2011-04-02 17:11:15 +0000
+++ nova/network/flat_vlan/db/sqlalchemy/api.py	2011-04-06 17:14:53 +0000
@@ -17,81 +17,31 @@
 """
 Implementation of SQLAlchemy backend.
 """
-
-from sqlalchemy import or_
-from sqlalchemy.exc import IntegrityError
-from sqlalchemy.orm import joinedload_all
-import warnings
-
-from nova import exception
-from nova.db import api as nova_db
-from nova.db.sqlalchemy import api as nova_api
 from nova.network.flat_vlan.db.sqlalchemy import models
 from nova.network.flat_vlan.db.sqlalchemy.session import get_session
 
 
-class DataAccessCache(object):
-    """A cache of Data Access Objects specific to sessions and contexts.
-
-    Creates one DAO object per session and set of context parameter
-    values, and caches it. The parameters currently used in the
-    context are:
-        - nova.db.sqlalchemy.api.is_admin_context(context)
-        - nova.db.sqlalchemy.api.can_read_deleted(context)
-    """
-
-    def __init__(self, dao_class):
-        self._dao_class = dao_class
-        self._cached_daos = {}
-
-    def get_dao(self, context, session):
-        """Get a DataAccess object.
-
-        If no cached DAO has been created for this session and this
-        context's parameter, a new DAO is created and
-        cached. Otherwise, the cached DAO is returned.
-
-        :param context: The request context.
-        :param session: The SQLAlchemy session to use as the Data
-            Access Object's data source.
-        """
-        is_admin = nova_api.is_admin_context(context)
-        can_read_deleted = nova_api.can_read_deleted(context)
-        key = (session, is_admin, can_read_deleted)
-        dao = self._cached_daos.get(key)
-        if dao is None:
-            dao = self._dao_class(session, is_admin, can_read_deleted)
-            self._cached_daos[key] = dao
-        return dao
-
-
-class DefaultSessionNetworkDataAccessFactory(object):
-    """A DAO factory that lazily uses the default session.
+class DefaultSessionFlatVlanNetworkDataAccessFactory(object):
+    """A DAO factory that lazily creates and uses the default session.
 
     This factory uses the default session for the flat VLAN network
     service, which it creates lazily when creating the first DAO.
     """
 
     def __init__(self):
-        self._dao_cache = DataAccessCache(models.FlatVlanNetworkDataAccess)
-        self._session = None
-
-    def get_session(self):
-        if self._session is None:
-            self._session = get_session()
-        return self._session
-
-    def get_dao(self, context):
+        self._dao = None
+
+    def get_dao(self):
         """Get a DataAccess object.
 
-        If no cached DAO has been created for this context's
-        parameter, a new DAO is created and cached. Otherwise, the
-        cached DAO is returned.
-
-        :param context: The request context.
+        If no cached DAO has been created for the default session, a
+        new DAO is created and cached. Otherwise, the cached DAO is
+        returned.
         """
-        return self._dao_cache.get_dao(context, self.get_session())
-
-
-dao_factory = DefaultSessionNetworkDataAccessFactory()
+        if self._dao is None:
+            self._dao = models.FlatVlanNetworkDataAccess(get_session())
+        return self._dao
+
+
+dao_factory = DefaultSessionFlatVlanNetworkDataAccessFactory()
 
 
=== modified file 'nova/network/flat_vlan/db/sqlalchemy/models.py'
--- nova/network/flat_vlan/db/sqlalchemy/models.py	2011-04-04 09:52:18 +0000
+++ nova/network/flat_vlan/db/sqlalchemy/models.py	2011-04-06 17:14:53 +0000
@@ -22,6 +22,7 @@
 from sqlalchemy.orm import joinedload, joinedload_all
 from sqlalchemy import Column, Boolean, Integer, String
 from sqlalchemy import ForeignKey
+from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.declarative import declarative_base
 
 from nova import exception
@@ -91,26 +92,20 @@
                                 'FloatingIp.fixed_ip_id == FixedIp.id,'
                                 'FloatingIp.deleted == False)')
     project_id = Column(String(255))
-    host = Column(String(255))  # , ForeignKey('hosts.id'))    
+    host = Column(String(255))  # , ForeignKey('hosts.id'))
 
 
 class DataAccess(object):
     """The base class to implement Data Access Objects.
     """
 
-    def __init__(self, session, is_admin, can_read_deleted):
+    def __init__(self, session):
         """Initialize this Data Access Object.
 
         :param session: The SQLAlchemy session to use as this Data
             Access Object's data source.
-        :param is_admin: Indicates if the request context is an
-            administrator.
-        :param can_read_deleted: Indicates if the request context has
-            access to deleted objects.
         """
         self._session = session
-        self._is_admin = is_admin
-        self._can_read_deleted = can_read_deleted
 
 
 class EthernetCardDataAccess(DataAccess):
@@ -130,9 +125,9 @@
 
         return result
 
-    def ethernet_card_get_all(self):
+    def ethernet_card_get_all(self, read_deleted=False):
         return self._session.query(self.ethernet_card_dto_class).\
-            filter_by(deleted=self._can_read_deleted).\
+            filter_by(deleted=read_deleted).\
             all()
 
     def ethernet_card_create(self, values):
@@ -171,8 +166,6 @@
         return result
 
     def network_get_by_bridge(self, bridge):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         result = self._session.query(self.network_dto_class).\
             filter_by(bridge=bridge).\
             filter_by(deleted=False).\
@@ -184,8 +177,6 @@
         return result
 
     def network_get_by_ethernet_card(self, ethernet_card_id):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         rv = self._session.query(self.network_dto_class).\
             filter_by(deleted=False).\
             join(self.network_dto_class.fixed_ips).\
@@ -193,7 +184,7 @@
             filter_by(deleted=False).\
             first()
         if not rv:
-            raise exception.NotFound(_('No network for ethernet card %s') % 
+            raise exception.NotFound(_('No network for ethernet card %s') %
                                      ethernet_card_id)
         return rv
 
@@ -204,9 +195,9 @@
                 filter_by(host=host).\
                 all()
 
-    def network_get_all(self):
+    def network_get_all(self, read_deleted=False):
         return self._session.query(self.network_dto_class).\
-            filter_by(deleted=self._can_read_deleted).\
+            filter_by(deleted=read_deleted).\
             all()
 
     def network_create(self, values):
@@ -216,8 +207,6 @@
         return network_ref
 
     def network_create_safe(self, values):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         try:
             return self.network_create(values)
         except IntegrityError:
@@ -272,8 +261,6 @@
         return result
 
     def network_get_associated_fixed_ips(self, network_id):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         return self._session.query(self.fixed_ip_dto_class).\
             options(joinedload_all('ethernet_card')).\
             filter_by(network_id=network_id).\
@@ -283,10 +270,10 @@
 
     network_get_associated_ips = network_get_associated_fixed_ips
 
-    def fixed_ip_get_by_address(self, address):
+    def fixed_ip_get_by_address(self, address, read_deleted=False):
         result = self._session.query(self.fixed_ip_dto_class).\
             filter_by(address=address).\
-            filter_by(deleted=self._can_read_deleted).\
+            filter_by(deleted=read_deleted).\
             options(joinedload('network')).\
             options(joinedload('ethernet_card')).\
             first()
@@ -301,16 +288,15 @@
             fixed_ip_ref.ethernet_card = None
             fixed_ip_ref.save(session=self._session)
 
-    def fixed_ip_get_by_ethernet_card(self, ethernet_card_id):
+    def fixed_ip_get_by_ethernet_card(self, ethernet_card_id,
+                                      read_deleted=False):
         result = self._session.query(self.fixed_ip_dto_class).\
             filter_by(ethernet_card_id=ethernet_card_id).\
-            filter_by(deleted=self._can_read_deleted).\
+            filter_by(deleted=read_deleted).\
             first()
         return result
 
     def fixed_ip_disassociate_all_by_timeout(self, host, time):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         inner_q = self._session.query(Network.id).\
                             filter_by(host=host).\
                             subquery()
@@ -330,53 +316,46 @@
 
     floating_ip_dto_class = FloatingIp
 
+    def floating_ip_count_by_project(self, project_id):
+        return self._session.query(self.floating_ip_dto_class).\
+            filter_by(project_id=project_id).\
+            filter_by(deleted=False).\
+            count()
+
     def floating_ip_allocate_address(self, host, project_id):
-        # TODO: Check authorizations much earlier before calling
-        # this. Doing that in DB layer is way too late.
-        # nova_api.authorize_project_context(context, project_id)
         with self._session.begin():
             floating_ip_ref = self._session.query(self.floating_ip_dto_class).\
-                filter_by(host=host).\
-                filter_by(fixed_ip_id=None).\
-                filter_by(project_id=None).\
-                filter_by(deleted=False).\
-                with_lockmode('update').\
-                first()
+                              filter_by(host=host).\
+                              filter_by(fixed_ip_id=None).\
+                              filter_by(project_id=None).\
+                              filter_by(deleted=False).\
+                              with_lockmode('update').\
+                              first()
             # NOTE(vish): if with_lockmode isn't supported, as in sqlite,
             #             then this has concurrency issues
             if not floating_ip_ref:
                 raise nova_db.NoMoreAddresses()
             floating_ip_ref['project_id'] = project_id
             self._session.add(floating_ip_ref)
-        return floating_ip_ref['address']
-
-    def floating_ip_count_by_project(self, project_id):
-        # TODO: Check authorizations much earlier before calling
-        # this. Doing that in DB layer is way too late.
-        # nova_api.authorize_project_context(context, project_id)
-        return self._session.query(self.floating_ip_dto_class).\
-            filter_by(project_id=project_id).\
-            filter_by(deleted=False).\
-            count()
+        return floating_ip_ref
 
     def floating_ip_deallocate(self, address):
         with self._session.begin():
-            # TODO(devcamcar): How to ensure floating id belongs to user?
-            floating_ip_ref = self.floating_ip_get_by_address(address)
+            floating_ip_ref = self.floating_ip_get_by_address(
+                address, read_deleted=False)
             floating_ip_ref['project_id'] = None
             floating_ip_ref.save(session=self._session)
 
     def floating_ip_destroy(self, address):
         with self._session.begin():
-            # TODO(devcamcar): Ensure address belongs to user.
-            floating_ip_ref = self.floating_ip_get_by_address(address)
+            floating_ip_ref = self.floating_ip_get_by_address(
+                address, read_deleted=False)
             floating_ip_ref.delete(session=self._session)
 
     def floating_ip_disassociate_by_address(self, address):
         with self._session.begin():
-            # TODO(devcamcar): Ensure address belongs to user.
-            #                  Does get_floating_ip_by_address handle this?
-            floating_ip_ref = self.floating_ip_get_by_address(address)
+            floating_ip_ref = self.floating_ip_get_by_address(
+                address, read_deleted=False)
             fixed_ip_ref = floating_ip_ref.fixed_ip
             if fixed_ip_ref:
                 fixed_ip_address = fixed_ip_ref['address']
@@ -387,38 +366,32 @@
         return fixed_ip_address
 
     def floating_ip_get_all(self):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         return self._session.query(self.floating_ip_dto_class).\
             options(joinedload_all('fixed_ip.ethernet_card')).\
             filter_by(deleted=False).\
             all()
 
     def floating_ip_get_all_by_project(self, project_id):
-        # TODO: Check authorizations much earlier before calling
-        # this. Doing that in DB layer is way too late.
-        # nova_api.authorize_project_context(context, project_id)
         return self._session.query(self.floating_ip_dto_class).\
             options(joinedload_all('fixed_ip.ethernet_card')).\
             filter_by(project_id=project_id).\
             filter_by(deleted=False).\
             all()
 
-    def floating_ip_get_by_address(self, address):
-        # TODO(devcamcar): Ensure the address belongs to user.
-        result = session.query(self.floating_ip_dto_class).\
+    def floating_ip_get_by_address(self, address, read_deleted=False):
+        result = self._session.query(self.floating_ip_dto_class).\
             options(joinedload_all('fixed_ip.network')).\
             filter_by(address=address).\
-            filter_by(deleted=self._can_read_deleted).\
+            filter_by(deleted=read_deleted).\
             first()
         if not result:
             raise exception.NotFound('No floating ip for address %s' % address)
-
         return result
 
     def floating_ip_update(self, address, values):
         with self._session.begin():
-            floating_ip_ref = self.floating_ip_get_by_address(address)
+            floating_ip_ref = self.floating_ip_get_by_address(
+                address, read_deleted=False)
             for (key, value) in values.iteritems():
                 floating_ip_ref[key] = value
             floating_ip_ref.save(session=self._session)
@@ -431,9 +404,8 @@
 
     def floating_ip_disassociate(self, address):
         with self._session.begin():
-            # TODO(devcamcar): Ensure address belongs to user.
-            #                  Does get_floating_ip_by_address handle this?
-            floating_ip_ref = self.floating_ip_get_by_address(address)
+            floating_ip_ref = self.floating_ip_get_by_address(
+                address, read_deleted=False)
             fixed_ip_ref = floating_ip_ref.fixed_ip
             if fixed_ip_ref:
                 fixed_ip_address = fixed_ip_ref['address']
@@ -441,11 +413,9 @@
                 fixed_ip_address = None
             floating_ip_ref.fixed_ip = None
             floating_ip_ref.save(session=self._session)
-        return fixed_ip_address
+        return fixed_ip_ref
 
     def floating_ip_get_all_by_host(self, host):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         return self._session.query(self.floating_ip_dto_class).\
                    options(joinedload_all('fixed_ip.ethernet_card')).\
                    filter_by(host=host).\
@@ -495,8 +465,6 @@
         return result
 
     def network_get_by_cidr(self, cidr):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         result = self._session.query(self.network_dto_class).\
             filter_by(cidr=cidr).first()
 
@@ -506,8 +474,6 @@
         return result
 
     def network_associate(self, project_id):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         with self._session.begin():
             network_ref = self._session.query(self.network_dto_class).\
                 filter_by(deleted=False).\
@@ -522,17 +488,17 @@
             self._session.add(network_ref)
         return network_ref
 
-    def fixed_ip_get_network(self, address):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
-        fixed_ip_ref = self.fixed_ip_get_by_address(address)
+    def fixed_ip_get_network(self, address, read_deleted=False):
+        fixed_ip_ref = self.fixed_ip_get_by_address(
+            address, read_deleted=read_deleted)
         return fixed_ip_ref.network
 
     def floating_ip_fixed_ip_associate(self, floating_address, fixed_address):
         with self._session.begin():
-            # TODO(devcamcar): How to ensure floating_id belongs to user?
-            floating_ip_ref = self.floating_ip_get_by_address(floating_address)
-            fixed_ip_ref = self.fixed_ip_get_by_address(fixed_address)
+            floating_ip_ref = self.floating_ip_get_by_address(
+                floating_address, read_deleted=False)
+            fixed_ip_ref = self.fixed_ip_get_by_address(
+                fixed_address, read_deleted=False)
             floating_ip_ref.fixed_ip = fixed_ip_ref
             floating_ip_ref.save(session=self._session)
 
@@ -553,8 +519,6 @@
             self._session.add(fixed_ip_ref)
 
     def fixed_ip_associate_pool(self, network_id, ethernet_card_id):
-        if not self._is_admin:
-            raise exception.NotAuthorized()
         with self._session.begin():
             network_or_none = or_(
                 self.fixed_ip_dto_class.network_id == network_id,
@@ -572,4 +536,4 @@
                 ip_ref.network = self.network_get(network_id)
                 ip_ref.ethernet_card = self.ethernet_card_get(ethernet_card_id)
                 self._session.add(ip_ref)
-            return ip_ref
 \ No newline at end of file
+            return ip_ref
 
=== modified file 'nova/network/flat_vlan/network.py'
--- nova/network/flat_vlan/network.py	2011-04-04 09:52:18 +0000
+++ nova/network/flat_vlan/network.py	2011-04-06 17:14:53 +0000
@@ -32,18 +32,18 @@
 LOG = logging.getLogger("nova.net_flat_vlan")
 LOG_DHCP = logging.getLogger('nova.dhcpbridge-flat-vlan')
 
-DhcpHost = collections.namedtuple('DhcpHost', 
+DhcpHost = collections.namedtuple('DhcpHost',
                                 'mac_address, hostname, ip_address, timestamp')
 
 class NetworkService(nova_manager.SchedulerDependentManager):
 
-    timeout_fixed_ips = (FLAGS.net_flat_vlan_use_vlan or 
+    timeout_fixed_ips = (FLAGS.net_flat_vlan_use_vlan or
                          FLAGS.net_flat_vlan_use_dhcp)
 
     def __init__(self, network_driver=None, dhcp_driver=None, ra_driver=None,
                  filter_driver=None, *args, **kwargs):
         """Initializes vlan network service.
-        
+
         Args:
            network_driver: The network driver for the OS.
            dhcp_driver: The DHCP driver to use for DHCP service.
@@ -57,8 +57,8 @@
             ra_driver = FLAGS.net_flat_vlan_ra_driver
         if not filter_driver:
             filter_driver = FLAGS.net_flat_vlan_filter_driver
-            
-        kwargs['db_driver'] = 'nova.network.flat_vlan.db.api' 
+
+        kwargs['db_driver'] = 'nova.network.flat_vlan.db.api'
         self.driver = utils.import_object(network_driver)
         self.dhcp_driver = utils.import_object(dhcp_driver)
         self.ra_driver = utils.import_object(ra_driver)
@@ -86,13 +86,14 @@
                     # NOTE(vish): The False here is because we ignore the case
                     #             that the ip is already bound.
                     self.driver.bind_floating_ip(floating_ip['address'], False)
-                    self.driver.ensure_floating_forward(floating_ip['address'],
-                                                        fixed_address)
-            self.filter_driver.metadata_forward()         
+                    self.filter_driver.ensure_floating_forward(
+                                          floating_ip['address'], fixed_address)
+
+            self.filter_driver.metadata_forward()
 
     def periodic_tasks(self, context=None):
         """Tasks to be run at a periodic interval.
-        
+
         Args:
            context: Nova context
         """
@@ -109,7 +110,7 @@
 
     def _set_vlan_host(self, context, network_id):
         """Sets up VLAN networking service host.
-        
+
         Args:
             context: Nova context
             network_id: ID of the network
@@ -136,11 +137,11 @@
                                             network_ref['vpn_private_address'])
 
         if not FLAGS.fake_network:
-            hosts = self._get_dhcp_hosts(context, network_id) 
+            hosts = self._get_dhcp_hosts(context, network_id)
             bridge = network_ref['bridge']
-            self.dhcp_driver.update_dhcp(bridge, 
-                                network_ref['gateway'], 
-                                network_ref['dhcp_start'], 
+            self.dhcp_driver.update_dhcp(bridge,
+                                network_ref['gateway'],
+                                network_ref['dhcp_start'],
                                 hosts,
                                 dhcp_script=FLAGS.net_flat_vlan_dhcpbridge)
             if(FLAGS.net_flat_vlan_use_ipv6):
@@ -148,11 +149,11 @@
                                          network_ref['cidr_v6'])
                 self.db.network_update(context, network_id,
                                        {"gateway_v6":
-                                        utils.get_my_linklocal(bridge)})       
+                                        utils.get_my_linklocal(bridge)})
 
     def _set_dhcp_host(self, context, network_id):
         """Sets up DHCP(no VLAN) networking service host.
-        
+
         Args:
             context: Nova context
             network_id: ID of the network
@@ -171,22 +172,22 @@
 
         if not FLAGS.fake_network:
             hosts = self._get_dhcp_hosts(context, network_id)
-            self.dhcp_driver.update_dhcp(bridge, 
-                            network_ref['gateway'], 
-                            network_ref['dhcp_start'], 
+            self.dhcp_driver.update_dhcp(bridge,
+                            network_ref['gateway'],
+                            network_ref['dhcp_start'],
                             hosts,
                             dhcp_script=FLAGS.net_flat_vlan_dhcpbridge)
-                                                     
+
             if(FLAGS.net_flat_vlan_use_ipv6):
                 self.ra_driver.update_ra(bridge,
                                          network_ref['cidr_v6'])
                 self.db.network_update(context, network_id,
                                        {"gateway_v6":
-                                        utils.get_my_linklocal(bridge)})         
-              
+                                        utils.get_my_linklocal(bridge)})
+
     def set_network_host(self, context, network_id):
         """Called when this host becomes the host for a network.
-        
+
         Args:
            context: Nova context to access DB.
            network_id: ID of the network
@@ -201,11 +202,11 @@
             net['host'] = self.host
             self.db.network_update(context, network_id, net)
 
-        return self.host            
-            
+        return self.host
+
     def _get_dhcp_hosts(self, context, network_id):
         """Get a list containing a network's hosts
-        
+
         Args:
            context: Nova context
            network_id: Network ID to get the DHCP hosts for.
@@ -224,10 +225,10 @@
                                       ip_address=fixed_ip_ref['address'],
                                       timestamp=None))
         return hosts
-        
+
     def allocate_fixed_ips(self, context, vnic_ids, is_vpn):
         """Gets a fixed ip from the pool.
-        
+
         Args:
            context: Nova context needed to access DB.
            vnic_ids: List of VNIC IDs.
@@ -236,29 +237,29 @@
         for vnic_id in vnic_ids:
             if FLAGS.net_flat_vlan_use_vlan:
                 ip_address = manager.bind_ip_to_ethernet_card_by_project(
-                                                                    context, 
+                                                                    context,
                                                                     vnic_id,
                                                                     is_vpn)
             else:
                 ip_address = manager.bind_ip_to_ethernet_card_by_bridge(
-                                                                    context, 
-                                                                    vnic_id)                                                       
+                                                                    context,
+                                                                    vnic_id)
 
             if not FLAGS.fake_network and (FLAGS.net_flat_vlan_use_vlan or
                                            FLAGS.net_flat_vlan_use_dhcp):
                 network_id = ip_address['network_id']
                 network_ref = self.db.network_get(context, network_id)
-                hosts = self._get_dhcp_hosts(context, network_id) 
-                self.dhcp_driver.update_dhcp(network_ref['bridge'], 
+                hosts = self._get_dhcp_hosts(context, network_id)
+                self.dhcp_driver.update_dhcp(network_ref['bridge'],
                                 network_ref['gateway'],
                                 network_ref['dhcp_start'],
-                                hosts, 
+                                hosts,
                                 dhcp_script=FLAGS.net_flat_vlan_dhcpbridge)
 
 
     def lease_fixed_ip(self, context, mac, address):
         """Called by dhcp-bridge when ip is leased.
-        
+
         Args:
            context: Nova context
            mac: MAC address to lease the IP address against.
@@ -267,19 +268,19 @@
         LOG.debug(_("Leasing IP %s"), address, context=context)
         fixed_ip_ref = self.db.fixed_ip_get_by_address(context, address)
         ethernet_card = fixed_ip_ref['ethernet_card']
-        instance = nova_db_api.instance_get_by_virtual_nic(context, 
+        instance = nova_db_api.instance_get_by_virtual_nic(context,
                                                            ethernet_card['id'])
         if not instance:
             raise exception.Error(_("IP %s leased that isn't associated") %
                                   address)
-    
+
         if nova_db_api.is_user_context(context):
             # Get the project for this IP
             nova_db_api.authorize_project_context(context, instance.project_id)
-    
+
         if ethernet_card['mac_address'] != mac:
             raise exception.Error(_("IP %(address)s leased to bad"
-                    " mac %s vs %s") % (ethernet_card['mac_address'], mac)) 
+                    " mac %s vs %s") % (ethernet_card['mac_address'], mac))
         now = datetime.datetime.utcnow()
         self.db.fixed_ip_update(context,
                                fixed_ip_ref['id'],
@@ -288,13 +289,13 @@
         if not fixed_ip_ref['allocated']:
             LOG.warn(_("IP %s leased that was already deallocated"), address,
                      context=context)
-    
+
     def get_dhcp_host_leases(self, context, interface):
         """Gets a list of leased hosts.
-        
+
         Args:
            context: Nova context
-           interface: network interface to get the DHCP leases. 
+           interface: network interface to get the DHCP leases.
         """
         network_ref = self.db.network_get_by_bridge(context, interface)
         hosts = []
@@ -305,21 +306,21 @@
             instance = nova_db_api.\
                        instance_get_by_virtual_nic(context,
                                                    ethernet_card['id'])
-    
+
             if instance['updated_at']:
                 timestamp = instance['updated_at']
             else:
                 timestamp = instance['created_at']
-            
+
             hosts.append(DhcpHost(mac_address=ethernet_card['mac_address'],
                                   hostname=instance['hostname'],
                                   ip_address=fixed_ip_ref['address'],
                                   timestamp=timestamp))
         return self.dhcp_driver.get_dhcp_leases(hosts)
-    
+
     def release_fixed_ip(self, context, mac, address):
         """Called by dhcp-bridge when ip is released.
-        
+
         Args:
            context: Nova context
            mac: MAC address to release the IP against.
@@ -328,7 +329,7 @@
         LOG.debug(_("Releasing IP %s"), address, context=context)
         fixed_ip_ref = self.db.fixed_ip_get_by_address(context, address)
         ethernet_card = fixed_ip_ref['ethernet_card']
-        instance = nova_db_api.instance_get_by_virtual_nic(context, 
+        instance = nova_db_api.instance_get_by_virtual_nic(context,
                                                            ethernet_card['id'])
         if not instance:
             raise exception.Error(_("IP %s released that isn't associated") %
@@ -340,7 +341,7 @@
 
         if ethernet_card['mac_address'] != mac:
             raise exception.Error(_("IP %(address)s leased to bad"
-                    " mac %s vs %s") % (ethernet_card['mac_address'], mac)) 
+                    " mac %s vs %s") % (ethernet_card['mac_address'], mac))
 
         if not fixed_ip_ref['leased']:
             LOG.warn(_("IP %s released that was not leased"), address,
@@ -355,25 +356,45 @@
             #             the code below will update the file if necessary
             if FLAGS.net_flat_vlan_update_dhcp_on_disassociate:
                 network_ref = fixed_ip['network']
-                hosts = self._get_dhcp_hosts(context, network_ref['id']) 
-                self.dhcp_driver.update_dhcp(network_ref['bridge'], 
-                                             network_ref['gateway'], 
-                                             network_ref['dhcp_start'], 
+                hosts = self._get_dhcp_hosts(context, network_ref['id'])
+                self.dhcp_driver.update_dhcp(network_ref['bridge'],
+                                             network_ref['gateway'],
+                                             network_ref['dhcp_start'],
                                              hosts,
                                              dhcp_script=FLAGS.\
                                                      net_flat_vlan_dhcpbridge)
 
-    def disassociate_floating_ip(self, context, floating_address):
-        """Disassociates a floating ip.
-        
-        Args:
-           context:  Nova context
-           floating_address: Floating IP address to diassociate.
-        """
-        fixed_address = self.db.floating_ip_disassociate(context,
-                                                         floating_address)
+    def get_host(self, context):
+        """Gets the host of the network service.
+        
+        Args:
+           context: Nova context object.  Unused here.
+        """
+        return self.host
+
+    def activate_public_ip(self, context, floating_address, fixed_address):
+        """Associates an floating ip to a fixed ip.
+
+        Args:
+           context: Nova context
+           floating_address: Floating IP address to map to fixed IP address.
+           fixed_address: Fixed IP address to map the floating IP address to.
+        """
+        self.driver.bind_floating_ip(floating_address)
+        self.filter_driver.ensure_floating_forward(floating_address,
+                                                   fixed_address)
+
+    def deactivate_public_ip(self, context, floating_address, fixed_address):
+        """Disassociates floating address and fixed address.
+        
+        Args:
+           context: Nova context
+            floating_address: Floating IP address to map to fixed IP address.
+           fixed_address: Fixed IP address to map the floating IP address to.
+        """
         self.driver.unbind_floating_ip(floating_address)
-        self.driver.remove_floating_forward(floating_address, fixed_address)
+        self.filter_driver.remove_floating_forward(floating_address, 
+                                                   fixed_address)
 
 
 class DHCPEventHandler(object):
@@ -388,7 +409,7 @@
             return NetworkService().get_dhcp_host_leases(ctxt, interface)
         else:
             return rpc.cast(ctxt,
-                     "%s.%s" % (FLAGS.net_flat_vlan_network_topic, 
+                     "%s.%s" % (FLAGS.net_flat_vlan_network_topic,
                                 FLAGS.host),
                      {"method": "get_dhcp_host_leases",
                       "args": {"interface": interface}})
@@ -402,7 +423,7 @@
             return NetworkService().lease_fixed_ip(ctxt, mac, ip_address)
         else:
             rpc.cast(ctxt,
-                     "%s.%s" % (FLAGS.net_flat_vlan_network_topic, 
+                     "%s.%s" % (FLAGS.net_flat_vlan_network_topic,
                                 FLAGS.host),
                      {"method": "lease_fixed_ip",
                       "args": {"mac": mac,
@@ -423,9 +444,9 @@
             NetworkService().release_fixed_ip(ctxt, mac, ip_address)
         else:
             rpc.cast(ctxt,
-                     "%s.%s" % (FLAGS.net_flat_vlan_network_topic, 
+                     "%s.%s" % (FLAGS.net_flat_vlan_network_topic,
                                 FLAGS.host),
                      {"method": "release_fixed_ip",
                       "args": {"mac": mac,
                                "address": ip_address}})
-    
+
 
=== modified file 'nova/network/service.py'
--- nova/network/service.py	2011-04-04 09:52:18 +0000
+++ nova/network/service.py	2011-04-06 17:14:53 +0000
@@ -19,14 +19,14 @@
     service management."""
 
 from nova import db
-from nova import flags    
+from nova import flags
 from nova import utils
 
 from zope import interface
 
 # Flag definitions
 FLAGS = flags.FLAGS
-flags.DEFINE_string('network_service_conf', 
+flags.DEFINE_string('network_service_conf',
                     '/etc/nova/nova-network-service.conf',
                     'Path to the network service configuration file.')
 flags.DEFINE_string('default_network_service', 'nova.network.flat_vlan',
@@ -37,102 +37,117 @@
 
     def get_net_agent():
         """Gets the Net agent service object.
-        
+
         Returns:
            Net agent object.
         """
-        
+
     def get_api_service():
         """Gets the API service object.
-        
+
         Returns:
            Network API service object.
         """
-        
+
     def get_os_api_service():
         """Gets the OpenStack API service object.
-        
+
         Returns:
            Network OpenStack API service object.
         """
 
 class INetworkApiService(interface.Interface):
     """A Network API service object."""
-    
+
     def create_vnic():
         """Creates a new VNIC.
-        
+
         Returns:
            The ID of the new VNIC.
         """
-        
+
     def get_project_vpn_address_and_port(context, project_id):
         """Gets the VPN IP address and port for a project
-        
+
         Args:
            context: Nova context object needed to access DB.
            project_id: Project to get the VPN IP and port for.
-           
+
         Returns:
            A tuple of VPN IP address and port number.
         """
 
+    def allocate_address(context, project_id, ip_quota):
+        """Gets the number of floating IPs associated with a project.
+
+        Args:
+            context: Nova context object needed to access the DB.
+            project_id: Project to allocate the address from.
+            ip_quota: Quota for IP addresses.
+
+        Returns:
+            An IP address.
+
+        Raises:
+            quota.QuotaError: Over the quota limit.
+        """
+
 class INetworkOpenStackApiService(interface.Interface):
     """An OpenStack Network API service object."""
-    
+
     def set_routes(route_map):
         """Set necessary routes for the plugin.
-        
+
         Args:
            route_map: NetworkServiceRouteMap object to add the routes to.
-        """ 
+        """
 
 class INetworkAgentService(interface.Interface):
     """An OpenStack network agent service object."""
-    
+
     def bind_vnics_to_ports(context, vnic_ids, is_vpn):
         """Gets a fixed ips from the pool.
-        
+
         Args:
            context: Nova context needed for DB access.
            vnic_ids: list of VNIC IDs
-           is_vpn: Boolean to check if the call is for VPN.          
+           is_vpn: Boolean to check if the call is for VPN.
         """
-        
+
     def setup_compute_network(context, vnic_ids, is_vpn):
         """Set up the compute node for networking.
-        
+
         Args:
            context: Nova context needed for DB access.
            vnic_ids: list of VNIC IDs
            is_vpn: Boolean to check if the call is for VPN.
         """
-        
+
     def teardown_compute_network(context, vnic_ids):
         """Clean up the compute node.
-        
+
         Args:
            context: Nova context needed for DB access.
            vnic_ids: list of VNIC IDs
         """
-        
+
     def requires_file_injection():
         """Indicates whether the plugin requires file injection.
-        
+
         Returns:
            True if the plugin requires file injection.
         """
-        
+
     def get_network_info(context, vnic_id):
         """Gets network data for a given VNIC.
-        
+
         Args:
            context: Nova context needed for DB access.
            vnic_id: VNIC ID to get the network information for.
-        
+
         Returns:
            A dictionary containing the following keys:
-           cidr, cidrv6, netmask, netmask_v6 gateway, gateway_v6, 
+           cidr, cidrv6, netmask, netmask_v6 gateway, gateway_v6,
            dhcp_server, broadcast, dns, mac_address,
            ip_address, bridge, gateway_v6, and netmast_v6
         """
@@ -142,7 +157,7 @@
 
     def __init__(self, mapper, service):
         """Initialize a NetworkServiceRouteMap object.
-        
+
         Args:
            mapper: python-routes mapper object to wrap.
            service: module of the network plugin service.
@@ -152,34 +167,34 @@
 
     def resource(self, member_name, collection_name, **kwargs):
         """Wrapper method for 'resource' method in python-routes mapper object.
-        
+
         This method does the same thing 'resource' method does for python-routes
-        module, but it also adds a route prefix from the network service name. 
-        
+        module, but it also adds a route prefix from the network service name.
+
         Args:
            member_name: REST member routes
            collection_name: REST collection routes
         """
         _, _, package_name = str(self._service.__package__).rpartition('.')
         kwargs.pop('path_prefix', None)
-        self._mapper.resource(member_name, collection_name, 
+        self._mapper.resource(member_name, collection_name,
                               path_prefix='/%s' % package_name, **kwargs)
 
 class NetworkServiceManager(object):
-    """Implements Borg design pattern to have a shared state of network 
+    """Implements Borg design pattern to have a shared state of network
     services.
     """
 
     __shared_state = {}
     _services = {}
-    
+
     def __init__(self):
         """Initialize services member dictionary variable.
         """
         self.__dict__ = self.__shared_state
 
     def _import_services(self):
-        """Loads the content of the configuration file and imports the 
+        """Loads the content of the configuration file and imports the
         modules.
         """
         self._services = {}
@@ -190,11 +205,11 @@
                 continue
             self._services[line] = utils.import_object(line)
         f.close()
-        
+
     @property
     def _services_dict(self):
         """Gets the services dictionary.  Loads the services if empty.
-        
+
         Returns:
            A dictionary of service name to service modules.
         """
@@ -205,11 +220,11 @@
     @classmethod
     def get_service_name(cls, context, project_id):
         """Gets the network service given a project ID.
-        
+
         Args:
            context: Nova context object needed for DB access.
            project_id: Project ID to get the service of.
-           
+
         Returns:
            Network service name for the project.
         """
@@ -220,20 +235,20 @@
 
     def get_service(self, context, project_id):
         """Gets the network service given a project ID.
-        
+
         Args:
            context: Nova context object needed for DB access.
            project_id: Project ID to get the service of.
-           
+
         Returns:
            Network service module for the project.
         """
         service = self.get_service_name(context, project_id)
         return self._services_dict[service]
-        
+
     def get_all_services(self):
         """Gets all the network services available.
-        
+
         Returns:
            Network service modules available.
         """
@@ -241,21 +256,21 @@
 
 def get_service_factory(context, project_id):
     """Gets the factory object for network service.
-    
+
     Args:
        context: Nova context needed for accessing DB.
        project_id: Project ID to get the appropriate network service.
-       
+
     Returns:
        A tuple of the service module and its NetworkServiceFactory object.
     """
     manager = NetworkServiceManager()
     service = manager.get_service(context, project_id)
     return (service, service.NetworkServiceFactory())
-    
+
 def get_all_service_factories():
     """Gets all the factory objects for network services.
-    
+
     Returns:
         A list of tuples of service module and its factory.
     """
 
=== modified file 'nova/virt/libvirt_conn.py'
--- nova/virt/libvirt_conn.py	2011-04-04 09:52:18 +0000
+++ nova/virt/libvirt_conn.py	2011-04-06 17:14:53 +0000
@@ -238,10 +238,7 @@
 
             vnics = db.virtual_nics_get_by_instance(ctxt, instance['id'])
             for vnic_id in vnics:
-                try:
-                    self.firewall_driver.prepare_vnic_filter(vnic_id, instance)
-                except:
-                    pass
+                self.firewall_driver.prepare_vnic_filter(vnic_id, instance)
 
     def _get_connection(self):
         if not self._wrapped_conn or not self._test_connection():