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

[Ryu Ishimoto]

Finished up the merging of three plugins(vlan, dhcp, flat) into one flat_vlan.

Finished up the merging of three plugins(vlan, dhcp, flat) into one flat_vlan.

=== removed file 'bin/nova-dhcpbridge-flat-dhcp'
--- bin/nova-dhcpbridge-flat-dhcp	2011-03-24 10:27:45 +0000
+++ bin/nova-dhcpbridge-flat-dhcp	1970-01-01 00:00:00 +0000
@@ -1,70 +0,0 @@
-#!/usr/bin/env python
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-"""
-Handle lease database updates from DHCP servers.
-"""
-
-import gettext
-import os
-import sys
-
-# 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 flags
-from nova import log as logging
-from nova import utils
-
-from nova.network.flat_dhcp.dhcp import DHCPEventHandler
-
-FLAGS = flags.FLAGS
-
-def main():
-    """Parse environment and arguments and call the approproate action."""
-    flagfile = os.environ.get('FLAGFILE', 
-                              FLAGS.ns_flat_dhcp_dhcpbridge_flagfile)
-    utils.default_flagfile(flagfile)
-    argv = FLAGS(sys.argv)
-    logging.setup()
-    interface = os.environ.get('DNSMASQ_INTERFACE', 'br0')
-    if int(os.environ.get('TESTING', '0')):
-        from nova.tests import fake_flags
-    action = argv[1]
-    if action in ['add', 'del', 'old']:
-        mac = argv[2]
-        ip = argv[3]
-        hostname = argv[4]
-        msg = _("Called %(action)s for mac %(mac)s with ip %(ip)s and"
-                " hostname %(hostname)s on interface %(interface)s") % locals()
-        LOG.debug(msg)
-        method = getattr(DHCPEventHandler, "%s_lease" % action)
-        method(mac, ip, hostname, interface)
-    else:
-        print DHCPEventHandler.init_leases(interface)
-
-if __name__ == "__main__":
-    main()
-

=== added file 'bin/nova-dhcpbridge-flat-vlan'
--- bin/nova-dhcpbridge-flat-vlan	1970-01-01 00:00:00 +0000
+++ bin/nova-dhcpbridge-flat-vlan	2011-04-04 00:58:27 +0000
@@ -0,0 +1,71 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 NTT.
+# 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.
+
+"""
+Handle lease database updates from DHCP servers.
+"""
+
+import gettext
+import os
+import sys
+
+# 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 flags
+from nova import log as logging
+from nova import utils
+
+from nova.network.flat_vlan import flags as net_flags
+from nova.network.flat_vlan.dhcp import DHCPEventHandler
+
+NET_FLAGS = net_flags.FlagAccessor()
+
+def main():
+    """Parse environment and arguments and call the approproate action."""
+    flagfile = os.environ.get('FLAGFILE', 
+                              NET_FLAGS.net_flat_vlan_dhcpbridge_flagfile)
+    utils.default_flagfile(flagfile)
+    argv = flags.FLAGS(sys.argv)
+    logging.setup()
+    interface = os.environ.get('DNSMASQ_INTERFACE', 'br0')
+    if int(os.environ.get('TESTING', '0')):
+        from nova.tests import fake_flags
+    action = argv[1]
+    if action in ['add', 'del', 'old']:
+        mac = argv[2]
+        ip = argv[3]
+        hostname = argv[4]
+        msg = _("Called %(action)s for mac %(mac)s with ip %(ip)s and"
+                " hostname %(hostname)s on interface %(interface)s") % locals()
+        LOG.debug(msg)
+        method = getattr(DHCPEventHandler, "%s_lease" % action)
+        method(mac, ip, hostname, interface)
+    else:
+        print DHCPEventHandler.init_leases(interface)
+
+if __name__ == "__main__":
+    main()
+

=== removed file 'bin/nova-dhcpbridge-vlan'
--- bin/nova-dhcpbridge-vlan	2011-03-24 10:27:45 +0000
+++ bin/nova-dhcpbridge-vlan	1970-01-01 00:00:00 +0000
@@ -1,69 +0,0 @@
-#!/usr/bin/env python
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-"""
-Handle lease database updates from DHCP servers.
-"""
-
-import gettext
-import os
-import sys
-
-# 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 flags
-from nova import log as logging
-from nova import utils
-
-from nova.network.vlan.dhcp import DHCPEventHandler
-
-FLAGS = flags.FLAGS
-
-def main():
-    """Parse environment and arguments and call the approproate action."""
-    flagfile = os.environ.get('FLAGFILE', FLAGS.ns_vlan_dhcpbridge_flagfile)
-    utils.default_flagfile(flagfile)
-    argv = FLAGS(sys.argv)
-    logging.setup()
-    interface = os.environ.get('DNSMASQ_INTERFACE', 'br0')
-    if int(os.environ.get('TESTING', '0')):
-        from nova.tests import fake_flags
-    action = argv[1]
-    if action in ['add', 'del', 'old']:
-        mac = argv[2]
-        ip = argv[3]
-        hostname = argv[4]
-        msg = _("Called %(action)s for mac %(mac)s with ip %(ip)s and"
-                " hostname %(hostname)s on interface %(interface)s") % locals()
-        LOG.debug(msg)
-        method = getattr(DHCPEventHandler, "%s_lease" % action)
-        method(mac, ip, hostname, interface)
-    else:
-        print DHCPEventHandler.init_leases(interface)
-
-if __name__ == "__main__":
-    main()
-

=== added file 'bin/nova-net-serv'
--- bin/nova-net-serv	1970-01-01 00:00:00 +0000
+++ bin/nova-net-serv	2011-04-04 00:58:27 +0000
@@ -0,0 +1,50 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 NTT.
+# 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.
+
+"""Starter script for Nova Network."""
+
+import eventlet
+eventlet.monkey_patch()
+
+import gettext
+import os
+import sys
+
+# 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 flags
+from nova import log as logging
+from nova import service
+from nova import utils
+
+if __name__ == '__main__':
+    utils.default_flagfile()
+    flags.FLAGS(sys.argv)
+    logging.setup()
+    manager_cls = 'nova.network.flat_vlan.network.NetworkService' 
+    net_service = service.Service.create(manager=manager_cls)
+    service.serve(net_service)
+    service.wait()

=== removed file 'bin/nova-net-vlan'
--- bin/nova-net-vlan	2011-03-24 10:27:45 +0000
+++ bin/nova-net-vlan	1970-01-01 00:00:00 +0000
@@ -1,50 +0,0 @@
-#!/usr/bin/env python
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-"""Starter script for Nova Network."""
-
-import eventlet
-eventlet.monkey_patch()
-
-import gettext
-import os
-import sys
-
-# 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 flags
-from nova import log as logging
-from nova import service
-from nova import utils
-
-if __name__ == '__main__':
-    utils.default_flagfile()
-    flags.FLAGS(sys.argv)
-    logging.setup()
-    manager_cls = 'nova.network.vlan.network.NetworkService' 
-    net_service = service.Service.create(manager=manager_cls)
-    service.serve(net_service)
-    service.wait()

=== removed directory 'nova/network/flat'
=== removed file 'nova/network/flat/__init__.py'
--- nova/network/flat/__init__.py	2011-03-30 10:33:12 +0000
+++ nova/network/flat/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-from zope import interface
-
-from nova.network import service
-from nova.network.flat_dhcp.compute import NetworkAgentService
-from nova.network.flat.api import NetworkApiService
-from nova.network.flat.api.openstack import NetworkOpenStackApiService
-
-class NetworkServiceFactory(object):
-    """Factory for network services"""
-
-    interface.implements(service.INetworkServiceFactory)
-    
-    def get_api_service(self):
-        """Gets the API service for this plugin."""
-        return NetworkApiService()
-    
-    def get_os_api_service(self):
-        """Gets OS API service for this plugin."""
-        return NetworkOpenStackApiService()
-    
-    def get_net_agent(self):
-        """Gets the net agent for this plugin."""
-        return NetworkAgentService()

=== removed directory 'nova/network/flat/api'
=== removed file 'nova/network/flat/api/__init__.py'
--- nova/network/flat/api/__init__.py	2011-03-30 10:11:03 +0000
+++ nova/network/flat/api/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-from zope import interface
-
-from nova.network import service
-from nova.network.flat.db import api as db_api
-from nova.network.flat.db import manager as db_manager
-
-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.
-
-        Returns:
-           The ID of the new VNIC.
-        """
-        # Create a new VNIC
-        vnic = db_manager.ethernet_card_create_with_random_mac(context)
-        return vnic.id
-
-    def get_project_vpn_address_and_port(self, _context, _project_id):
-        """Does not apply."""
-        return (None, None)

=== removed directory 'nova/network/flat/api/openstack'
=== removed file 'nova/network/flat/api/openstack/__init__.py'
--- nova/network/flat/api/openstack/__init__.py	2011-03-30 10:11:03 +0000
+++ nova/network/flat/api/openstack/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,45 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-from zope import interface
-
-from nova.network import service
-from nova.network.flat.api.openstack import networks    
-from nova.network.flat.api.openstack import ports
-from nova.network.flat.api.openstack import virtual_nics
-
-class NetworkOpenStackApiService(object):
-    """OpenStack API service object for this plugin."""
-
-    interface.implements(service.INetworkOpenStackApiService)
-
-    def set_routes(self, route_map):
-        """Generic API method to set up all the routes.
-        
-        Args:
-           route_map: NetworkServiceRouteMap object to add the routes to.
-        """
-        # Set up VNIC
-        route_map.resource("vnics", "/vnics",
-                           controller=virtual_nics.Controller())
-    
-        # Set up networks  
-        route_map.resource("networks", "/networks",
-                           controller=networks.Controller())
-    
-        # Set up ports
-        route_map.resource("ports", "/ports", 
-                           controller=ports.Controller())

=== removed file 'nova/network/flat/api/openstack/networks.py'
--- nova/network/flat/api/openstack/networks.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/api/openstack/networks.py	1970-01-01 00:00:00 +0000
@@ -1,78 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-from webob import exc
-
-from nova import exception
-from nova import wsgi
-from nova.api.openstack import faults
-from nova.db import base
-from nova.network.flat import common
-from nova.network.flat import db
-from nova.network.flat.db import manager
-
-class Controller(wsgi.Controller):
-    """ The Networks API controller for the OpenStack API """
-    
-    def __init__(self):
-        super(Controller, self).__init__()
-
-    def create(self, req):
-        """ Creates a new network. """        
-        env = self._deserialize(req.body, req.get_content_type())
-        if not env:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-
-        networks = manager.network_create(req.environ['nova.context'], 
-                                          env['cidr'], 
-                                          int(env['num_networks']),
-                                          int(env['network_size']),
-                                          env['cidr_v6'])
-        items = [common.filter_keys(item, ('id', 'cidr')) 
-                 for item in networks] 
-        return dict(ids=items)
-    
-    def update(self, req, id):
-        """Updates a network."""
-        env = self._deserialize(req.body, req.get_content_type())
-        if not env:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        
-        # Currently only host can be updated.
-        if 'host' in env:
-            try:
-                manager.network_update_host(req.environ['nova.context'], id, 
-                                            env['host'])
-            except exception.NotFound:
-                return faults.Fault(exc.HTTPNotFound())
-
-        return exc.HTTPNoContent()
-    
-    def show(self, req, id):
-        """ Gets the network with ID given """
-        try:
-            network = db.api.network_get(req.environ['nova.context'], id)
-            return dict(id=network.id, cidr=network.cidr)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-
-    def delete(self, req, id):
-        """ Destroys a network """
-        try:
-            db.api.network_delete(req.environ['nova.context'], id)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()

=== removed file 'nova/network/flat/api/openstack/ports.py'
--- nova/network/flat/api/openstack/ports.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/api/openstack/ports.py	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-from nova import wsgi
-from nova.api.openstack import common as nova_common
-from nova.api.openstack import faults
-from nova.network.flat import common
-from nova.network.flat import db
-
-class Controller(wsgi.Controller):
-    """ The Ports API controller for the OpenStack API """
-    
-    def __init__(self):
-        super(Controller, self).__init__()
-    
-    def index(self, req):
-        """Return all port/IPs in brief"""
-        items = db.api.ip_address_get_all(req.environ['nova.context'])
-        items = nova_common.limited(items, req)
-        items = [common.filter_keys(item, ('id', 'address')) for item in items]
-        return dict(ports=items)

=== removed file 'nova/network/flat/api/openstack/virtual_nics.py'
--- nova/network/flat/api/openstack/virtual_nics.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/api/openstack/virtual_nics.py	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-from webob import exc
-
-from nova.api.openstack import common as nova_common
-from nova import exception
-from nova import wsgi
-from nova.api.openstack import faults
-from nova.db import base
-from nova.network.flat import common
-from nova.network.flat import db
-from nova.network.flat.db import manager
-
-class Controller(wsgi.Controller):
-    """ The Virtual NICs API controller for the OpenStack API """
-    
-    def __init__(self):
-        super(Controller, self).__init__()
-
-    def index(self, req):
-        """Return all ethernet cards in brief"""
-        items = db.api.ethernet_card_get_all(req.environ['nova.context'])
-        items = nova_common.limited(items, req)
-        items = [common.filter_keys(item, ('id', 'mac_address')) 
-                 for item in items]
-        return dict(ethernet_cards=items)        
-    
-    def create(self, req):
-        """ Creates a new ethernet card. """
-        ethernet_card = manager.ethernet_card_create_with_random_mac(
-                            req.environ['nova.context'])
-        return dict(id=ethernet_card.id)
- 
-    def update(self, req, id):
-        """Update an ethernet card"""
-        return exc.HTTPNoContent()
-    
-    def show(self, req, id):
-        """ Gets the ethernet card with ID given """
-        try:
-            ethernet_card = db.api.ethernet_card_get(
-                                req.environ['nova.context'], id)
-            return dict(id=ethernet_card.id,
-                        mac_address=ethernet_card.mac_address)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-
-    def delete(self, req, id):
-        """ Destroys an ethernet card """
-        try:
-            db.api.ethernet_card_delete(req.environ['nova.context'], id)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()

=== removed file 'nova/network/flat/common.py'
--- nova/network/flat/common.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/common.py	1970-01-01 00:00:00 +0000
@@ -1,36 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-# 
-#   Common utility methods and classes are defined here.
-# 
-
-import IPy
-
-def filter_keys(item, keys):
-    """
-    Filters all model attributes except for keys
-    item is a dict
-    """
-    return dict((k, v) for k, v in item.iteritems() if k in keys)
-
-def get_net_and_mask(cidr):
-    """
-    Gets network IP and netmask from cidr.
-    """
-    net = IPy.IP(cidr)
-    return str(net.net()), str(net.netmask())

=== removed file 'nova/network/flat/compute.py'
--- nova/network/flat/compute.py	2011-03-30 10:33:12 +0000
+++ nova/network/flat/compute.py	1970-01-01 00:00:00 +0000
@@ -1,157 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-import socket
-from zope import interface
-
-from nova import flags
-from nova import rpc
-from nova import utils
-from nova.network import service
-from nova.network.flat import common
-from nova.network.flat.db import api as db_api
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_network_host', socket.gethostname(),
-                    'Network host to use for ip allocation in flat modes')
-flags.DEFINE_string('ns_flat_network_topic', 'net-flat', 
-                    'the topic network nodes listen on')
-flags.DEFINE_string('ns_flat_network_bridge', 'br100',
-                    'Bridge for simple network instances')
-flags.DEFINE_bool('ns_flat_network_fake_call', False,
-                  'If True, skip using the queue and make local calls')
-
-def _queue_get_for(topic, physical_node_id):
-    return "%s.%s" % (topic, physical_node_id)
-
-def _get_network_topic(context, **kwargs):
-    """Retrieves the network host for a project on this host"""
-    if FLAGS.stub_network:
-        host = FLAGS.ns_flat_network_host
-    else:
-        host = _get_network_host(context)
-    return _queue_get_for(FLAGS.ns_flat_network_topic,
-                          host)
-
-def _get_network_host(context):
-    """Get the network host for the current context."""
-    network_ref = db_api.network_get_by_bridge(context,
-                                               FLAGS.ns_flat_network_bridge)
-    host = network_ref['host']
-    if not host:
-        topic = _queue_get_for(FLAGS.ns_flat_network_topic,
-                               FLAGS.ns_flat_network_host)
-        if FLAGS.ns_flat_network_fake_call:
-            return _set_network_host(context, network_ref['id'])
-        host = rpc.call(context,
-                        FLAGS.ns_flat_network_topic,
-                        {"method": "set_network_host",
-                         "args": {"network_id": network_ref['id']}})
-    return host
-
-def _set_network_host(context, network_id):
-    """Safely sets the host of the network."""
-    db_api.network_update(context,
-                          network_id,
-                          {"host":FLAGS.host,
-                           "dns": FLAGS.ns_flat_dns})
-    return FLAGS.host 
-
-class NetworkAgentService(object):
-    """An OpenStack network agent service object."""
-
-    interface.implements(service.INetworkOpenStackApiService)
-    
-    def bind_vnics_to_ports(self, 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.          
-        """
-        rpc.call(context,
-                 _get_network_topic(context),
-                 {"method": "allocate_fixed_ips",
-                  "args": {"vnic_ids": vnic_ids}})
-    
-    def setup_compute_network(self, context, vnic_ids): 
-        """Nothing needs to be done.
-        """
-        pass
-    
-    def teardown_compute_network(self, context, vnic_ids):
-        """Clean up the compute node.
-        
-        Args:
-           context: Nova context needed for DB access.
-           vnic_ids: list of VNIC IDs
-        """
-        ctxt = context.elevated() 
-        for vnic_id in vnic_ids:
-            ip = vnic_id.get('fixed_ip')
-            if not FLAGS.stub_network and ip:
-    
-                address = ip['address']
-                db_api.ip_address_update(ctxt, address, 
-                                              {'allocated': False})
-                db_api.ip_address_disassociate(ctxt, address)
-    
-    def requires_file_injection(self):
-        """This service requires file injection.
-        """
-        return True
-    
-    def get_network_info(self, 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, 
-           dhcp_server, broadcast, dns, ra_server, mac_address,
-           ip_address, bridge, and address_v6
-        """
-        ethernet_card = db_api.ethernet_card_get(context, vnic_id)
-        if not ethernet_card:
-            raise ValueError("Invalid vnic ID!")
-    
-        # Get the IP address associated with this VNIC
-        ip_address = db_api.ip_address_get_by_ethernet_card(context, 
-                                                            ethernet_card.id)
-        if not ip_address:
-            raise ValueError("VNIC is not mapped to IP!")
-    
-        network = ip_address.network
-        if network['cidr_v6']:
-            ipv6_addr = utils.to_global_ipv6(network['cidr_v6'],
-                                             ethernet_card['mac_address'])
-        else:
-            ipv6_addr = None
-    
-        net, mask = common.get_net_and_mask(network['cidr'])
-        return dict(mac_address=ethernet_card['mac_address'],
-                    ip_address=ip_address['address'], bridge=network['bridge'],
-                    cidr=network['cidr'], netmask=network['netmask'],
-                    gateway=network['gateway'], broadcast=network['broadcast'],
-                    dns=network['dns'], dhcp_server=None, 
-                    cidr_v6=network['cidr_v6'], address_v6=ipv6_addr, 
-                    ra_server=None, netmask_v6=None, gateway_v6=None,
-                    net=net, mask=mask) 
-

=== removed directory 'nova/network/flat/db'
=== removed file 'nova/network/flat/db/__init__.py'
--- nova/network/flat/db/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,21 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-DB abstraction for Nova
-"""
-

=== removed file 'nova/network/flat/db/api.py'
--- nova/network/flat/db/api.py	2011-03-24 13:55:17 +0000
+++ nova/network/flat/db/api.py	1970-01-01 00:00:00 +0000
@@ -1,143 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-Defines interface for DB access.
-
-The underlying driver is loaded as a :class:`LazyPluggable`.
-"""
-from nova import flags
-from nova import utils
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_db_backend', 
-                    'sqlalchemy',
-                    'Default backend to use for SQL.')
-
-IMPL = utils.LazyPluggable(FLAGS['ns_flat_db_backend'],
-                           sqlalchemy='nova.network.flat.db.sqlalchemy.api')
-
-###################
-
-def ethernet_card_get(context, id):
-    """Get ethernet card by id."""
-    return IMPL.dao_factory.get_dao(context).\
-        ethernet_card_get(id)
-
-def ethernet_card_create(context, values):
-    """Create a new ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
-        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()
-
-def ethernet_card_update(context, ethernet_card_id, values):
-    """Update ethernet card.""" 
-    return IMPL.dao_factory.get_dao(context).\
-        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).\
-        ethernet_card_delete(ethernet_card_id)
-
-def network_get(context, id):
-    """Get network by id."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_get(id)
-
-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).\
-        network_get_by_bridge(bridge)
-
-def host_get_networks(context, host):
-    """Get networks for a given host."""
-    return IMPL.dao_factory.get_dao(context).\
-        host_get_networks(host)
-    
-def network_create(context, values):
-    """Create a new network."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_create(values)
-
-def network_create_safe(context, values):
-    """Create a new network.  Returns None when there is an exception"""
-    return IMPL.dao_factory.get_dao(context).\
-        network_create_safe(values)
-
-def network_get_all(context):
-    """Get all networks."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_get_all()
-
-def network_update(context, network_id, values):
-    """Update network.""" 
-    return IMPL.dao_factory.get_dao(context).\
-        network_update(network_id, values)
-
-def network_delete(context, network_id):
-    """Delete network."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_delete(network_id)
-
-def ip_address_get(context, id):
-    """Get IP address by id."""
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_get(id)
-
-def ip_address_get_by_ethernet_card(context, ethernet_card_id):
-    """Get IP address by ethernet card id."""
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_get_by_ethernet_card(ethernet_card_id)
-
-def ip_address_disassociate(context, address):
-    """Disassocaites IP from ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_disassociate(address)
-
-def ip_address_get_by_address(self, address):
-    """Get IP record by IP address."""
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_get_by_address(address)
-
-def ip_address_create(context, values):
-    """Create a new IP address."""
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_create(values)
-
-def ip_address_get_all(context):
-    """Get all IP addresses."""
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_get_all()
-
-def ip_address_update(context, ip_address_id, values):
-    """Update IP address.""" 
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_update(ip_address_id, values)
-
-def ip_address_delete(context, ip_address_id):
-    """Delete IP address."""
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_delete(ip_address_id)
-
-def ip_address_associate_pool(context, network_id, ethernet_card_id):
-    """Associate IP address to network and ethernet card.""" 
-    return IMPL.dao_factory.get_dao(context).\
-        ip_address_associate_pool(network_id, ethernet_card_id)

=== removed file 'nova/network/flat/db/manager.py'
--- nova/network/flat/db/manager.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/manager.py	1970-01-01 00:00:00 +0000
@@ -1,121 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-"""
-Wrapper APIs for DB models should be defined here.
-"""
-import IPy
-import math
-
-from nova import flags
-from nova import utils
-
-from nova.network.flat.db import api
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_bridge',
-                    'br100',
-                    'Bridge for simple network instances')
-
-BOTTOM_RESERVED_IPS = 2
-TOP_RESERVED_IPS = 1
-
-def _create_fixed_ips(context, network_id):
-    """Create all fixed ips for network."""
-    network_ref = api.network_get(context, network_id)
-    net = IPy.IP(network_ref['cidr'])
-    num_ips = len(net)
-    for index in range(num_ips):
-        address = str(net[index])
-        if index < BOTTOM_RESERVED_IPS or num_ips - index < TOP_RESERVED_IPS:
-            reserved = True
-        else:
-            reserved = False
-
-        api.ip_address_create(context, 
-                              {'network_id': network_id,
-                                'address': address,
-                                'reserved': reserved})
-
-def network_create(context, cidr, num_networks, network_size,
-           cidr_v6, *args, **kwargs):
-    """Create networks based on parameters."""
-    fixed_net = IPy.IP(cidr)
-    fixed_net_v6 = IPy.IP(cidr_v6)
-    significant_bits_v6 = 64
-    networks = []
-    for index in range(num_networks):
-        start = index * network_size
-        significant_bits = 32 - int(math.log(network_size, 2))
-        cidr = "%s/%s" % (fixed_net[start], significant_bits)
-        project_net = IPy.IP(cidr)
-        net = {}
-        net['bridge'] = FLAGS.ns_flat_bridge
-        net['cidr'] = cidr
-        net['netmask'] = str(project_net.netmask())
-        net['gateway'] = str(project_net[1])
-        net['broadcast'] = str(project_net.broadcast())
-
-        if(FLAGS.use_ipv6):
-            cidr_v6 = "%s/%s" % (fixed_net_v6[0], significant_bits_v6)
-            net['cidr_v6'] = cidr_v6
-
-        network_ref = api.network_create_safe(context, net)
-
-        if network_ref:
-            networks.append(network_ref)
-            _create_fixed_ips(context, network_ref['id'])
-
-    return networks
-
-def allocate_ip(context, ethernet_card_id, *args, **kwargs):
-    """Gets an IP from the pool."""
-    network_ref = api.network_get_by_bridge(context,
-                                            FLAGS.ns_flat_bridge)
-    ip = api.ip_address_associate_pool(context.elevated(),
-                                       network_ref['id'],
-                                       ethernet_card_id)
-    api.ip_address_update(context, ip.id, {'allocated': True})
-    return ip
-
-def bind_ip_to_ethernet_card(context, ethernet_card_id):
-    """Assigns IP to ethernet card."""
-    
-    # Get the ethernet card
-    ethernet_card = api.ethernet_card_get(context, ethernet_card_id)
-    # TODO: Throw a better exception.
-    if not ethernet_card:
-        raise ValueError("There is not VNIC with ID %s" % ethernet_card_id)
-
-    ip_address = api.ip_address_get_by_ethernet_card(context, 
-                                                     ethernet_card_id)
-    # Check to see if this ethernet card does not have IP allocated.
-    if not ip_address:
-        ip_address = allocate_ip(context, ethernet_card_id)
-
-    return ip_address
-
-def network_update_host(context, id, host):
-    """Updates network host"""
-    return api.network_update(context, id, dict(host=host))
-
-def ethernet_card_create_with_random_mac(context):
-    """Creates a new ethernet card"""
-    mac_address = utils.generate_mac()
-    return api.ethernet_card_create(context, dict(mac_address=mac_address))
-
-    

=== removed directory 'nova/network/flat/db/sqlalchemy'
=== removed file 'nova/network/flat/db/sqlalchemy/__init__.py'
--- nova/network/flat/db/sqlalchemy/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/sqlalchemy/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.

=== removed file 'nova/network/flat/db/sqlalchemy/api.py'
--- nova/network/flat/db/sqlalchemy/api.py	2011-03-24 15:29:16 +0000
+++ nova/network/flat/db/sqlalchemy/api.py	1970-01-01 00:00:00 +0000
@@ -1,94 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-Implementation of SQLAlchemy backend.
-"""
-from sqlalchemy import or_
-from sqlalchemy.exc import IntegrityError
-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.db.sqlalchemy import models
-from nova.network.flat.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 DefaultSessionFlatNetworkDataAccessFactory(object):
-    """A DAO factory that lazily uses the default session.
-
-    This factory uses the default session for the flat network
-    service, which it creates lazily when creating the first DAO.
-    """
-
-    def __init__(self):
-        self._dao_cache = DataAccessCache(models.FlatNetworkDataAccess)
-        self._session = None
-
-    def get_session(self):
-        if self._session is None:
-            self._session = get_session()
-        return self._session
-
-    def get_dao(self, context):
-        """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.
-        """
-        return self._dao_cache.get_dao(context, self.get_session())
-
-
-dao_factory = DefaultSessionFlatNetworkDataAccessFactory()

=== removed directory 'nova/network/flat/db/sqlalchemy/migrate_repo'
=== removed file 'nova/network/flat/db/sqlalchemy/migrate_repo/README'
--- nova/network/flat/db/sqlalchemy/migrate_repo/README	2011-03-15 04:26:43 +0000
+++ nova/network/flat/db/sqlalchemy/migrate_repo/README	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-This is a database migration repository.
-
-More information at
-http://code.google.com/p/sqlalchemy-migrate/

=== removed file 'nova/network/flat/db/sqlalchemy/migrate_repo/__init__.py'
--- nova/network/flat/db/sqlalchemy/migrate_repo/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/sqlalchemy/migrate_repo/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
\ No newline at end of file

=== removed file 'nova/network/flat/db/sqlalchemy/migrate_repo/manage.py'
--- nova/network/flat/db/sqlalchemy/migrate_repo/manage.py	2011-03-15 04:26:43 +0000
+++ nova/network/flat/db/sqlalchemy/migrate_repo/manage.py	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-#!/usr/bin/env python
-from migrate.versioning.shell import main
-if __name__ == '__main__':
-    main(debug='False', repository='.')

=== removed file 'nova/network/flat/db/sqlalchemy/migrate_repo/migrate.cfg'
--- nova/network/flat/db/sqlalchemy/migrate_repo/migrate.cfg	2011-03-15 04:26:43 +0000
+++ nova/network/flat/db/sqlalchemy/migrate_repo/migrate.cfg	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-[db_settings]
-# Used to identify which repository this database is versioned under.
-# You can use the name of your project.
-repository_id=nova_network_flat
-
-# The name of the database table used to track the schema version.
-# This name shouldn't already be used by your project.
-# If this is changed once a database is under version control, you'll need to 
-# change the table name in each database too. 
-version_table=migrate_version
-
-# When committing a change script, Migrate will attempt to generate the 
-# sql for all supported databases; normally, if one of them fails - probably
-# because you don't have that database installed - it is ignored and the 
-# commit continues, perhaps ending successfully. 
-# Databases in this list MUST compile successfully during a commit, or the 
-# entire commit will fail. List the databases your application will actually 
-# be using to ensure your updates to that database work properly.
-# This must be a list; example: ['postgres','sqlite']
-required_dbs=[]

=== removed directory 'nova/network/flat/db/sqlalchemy/migrate_repo/versions'
=== removed file 'nova/network/flat/db/sqlalchemy/migrate_repo/versions/001_diablo.py'
--- nova/network/flat/db/sqlalchemy/migrate_repo/versions/001_diablo.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/sqlalchemy/migrate_repo/versions/001_diablo.py	1970-01-01 00:00:00 +0000
@@ -1,107 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-meta = MetaData()
-
-#
-# New Tables
-#
-ip_addresses = Table(
-        'ip_addresses', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('address',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('network_id', Integer(), ForeignKey('networks.id'),               
-               nullable=True),
-        Column('allocated', Boolean(create_constraint=True, name=None)),
-        Column('reserved', Boolean(create_constraint=True, name=None)),
-        Column('ethernet_card_id', Integer(), ForeignKey('ethernet_cards.id'),
-               nullable=True),
-        Column("addressV6",
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column("netmaskV6",
-               String(length=3, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column("gatewayV6",
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        )
-
-ethernet_cards = Table(
-        'ethernet_cards', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('mac_address', String(255), nullable=False),
-        )
-
-networks = Table(
-        'networks', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True),
-        Column('cidr', String(255)),
-        Column('netmask', String(255)),
-        Column('bridge', String(255)),
-        Column('gateway', String(255)),
-        Column('broadcast', String(255)),
-        Column('dns',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('cidr_v6',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('host', String(255)),
-        )
-
-def upgrade(migrate_engine):
-    meta.bind = migrate_engine
-
-    for table in (ethernet_cards, networks, ip_addresses):
-        try:    
-            table.create()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while creating table')
-            raise
-
-def downgrade(migrate_engine):
-    meta.bind = migrate_engine
-
-    for table in (ip_addresses, networks, ethernet_cards):
-        try:    
-            table.drop()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while dropping table')
-            raise
-

=== removed file 'nova/network/flat/db/sqlalchemy/migrate_repo/versions/__init__.py'
--- nova/network/flat/db/sqlalchemy/migrate_repo/versions/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/sqlalchemy/migrate_repo/versions/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
\ No newline at end of file

=== removed file 'nova/network/flat/db/sqlalchemy/migration.py'
--- nova/network/flat/db/sqlalchemy/migration.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/sqlalchemy/migration.py	1970-01-01 00:00:00 +0000
@@ -1,65 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-import os
-
-from nova import flags
-
-import sqlalchemy
-from migrate.versioning import api as versioning_api
-from migrate.versioning import exceptions as versioning_exceptions
-
-FLAGS = flags.FLAGS
-
-
-def db_sync(version=None):
-    db_version()
-    repo_path = _find_migrate_repo()
-    return versioning_api.upgrade(FLAGS.sql_connection, repo_path, version)
-
-
-def db_version():
-    repo_path = _find_migrate_repo()
-    try:
-        return versioning_api.db_version(FLAGS.sql_connection, repo_path)
-    except versioning_exceptions.DatabaseNotControlledError:
-        # If we aren't version controlled we may already have the database
-        # in the state from before we started version control, check for that
-        # and set up version_control appropriately
-        meta = sqlalchemy.MetaData()
-        engine = sqlalchemy.create_engine(FLAGS.sql_connection, echo=False)
-        meta.reflect(bind=engine)
-        try:
-            for table in ('ethernet_cards', 'networks'):
-                assert table in meta.tables
-            return db_version_control(1)
-        except AssertionError:
-            return db_version_control(0)
-
-
-def db_version_control(version=None):
-    repo_path = _find_migrate_repo()
-    versioning_api.version_control(FLAGS.sql_connection, repo_path, version)
-    return version
-
-
-def _find_migrate_repo():
-    """Get the path for the migrate repository."""
-    path = os.path.join(os.path.abspath(os.path.dirname(__file__)),
-                        'migrate_repo')
-    assert os.path.exists(path)
-    return path

=== removed file 'nova/network/flat/db/sqlalchemy/models.py'
--- nova/network/flat/db/sqlalchemy/models.py	2011-03-25 00:04:43 +0000
+++ nova/network/flat/db/sqlalchemy/models.py	1970-01-01 00:00:00 +0000
@@ -1,314 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-SQLAlchemy models for flat network service data.
-"""
-from sqlalchemy import or_
-
-from sqlalchemy.orm import relationship, backref
-from sqlalchemy.orm import joinedload
-from sqlalchemy import Column, Boolean, Integer, String
-from sqlalchemy import ForeignKey
-from sqlalchemy.ext.declarative import declarative_base
-
-from nova import exception
-from nova.db.sqlalchemy.models import NovaBase
-
-
-BASE = declarative_base()
-
-
-# ----------------------
-# Data Transfer Objects.
-# ----------------------
-
-class EthernetCard(BASE, NovaBase):
-    """Represents an ethernet card."""
-    __tablename__ = 'ethernet_cards'
-    id = Column(Integer, primary_key=True)
-    mac_address = Column(String(255), nullable=False, unique=True)
-
-
-class Network(BASE, NovaBase):
-    """Represents a simple IP network."""
-    __tablename__ = 'networks'
-    id = Column(Integer, primary_key=True)
-    cidr = Column(String(255))
-    netmask = Column(String(255))
-    bridge = Column(String(255))
-    gateway = Column(String(255))
-    broadcast = Column(String(255))
-    dns = Column(String(255))
-    cidr_v6 = Column(String(255), unique=True)
-    host = Column(String(255))  # , ForeignKey('hosts.id'))
-
-    
-class IpAddress(BASE, NovaBase):
-    """Represents a ip address for an ethernet card."""
-    __tablename__ = 'ip_addresses'
-    id = Column(Integer, primary_key=True)
-    address = Column(String(255))
-    network_id = Column(Integer, ForeignKey('networks.id'), nullable=True)
-    network = relationship(Network, backref=backref('ip_addresses'))
-    allocated = Column(Boolean, default=False)
-    reserved = Column(Boolean, default=False)
-    ethernet_card_id = Column(Integer, ForeignKey('ethernet_cards.id'))
-    ethernet_card = relationship(EthernetCard, backref=backref('ip_addresses'))
-    addressV6 = Column(String(255))
-    netmaskV6 = Column(String(3))
-    gatewayV6 = Column(String(255))
-
-
-# ----------------------
-# Data Access Objects.
-# ----------------------
-
-class DataAccess(object):
-    """The base class to implement Data Access Objects.
-    """
-
-    def __init__(self, session, is_admin, can_read_deleted):
-        """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):
-    """A Data Access Object to access ethernet cards.
-    """
-
-    ethernet_card_dto_class = EthernetCard
-
-    def ethernet_card_get(self, id):
-        result = self._session.query(self.ethernet_card_dto_class).\
-            filter_by(deleted=False).\
-            filter_by(id=id).\
-            first()
-
-        if not result:
-            raise exception.NotFound(_("No ethernet_card with id %s") % id)
-
-        return result
-
-    def ethernet_card_get_all(self):
-        return self._session.query(self.ethernet_card_dto_class).\
-            filter_by(deleted=self._can_read_deleted).\
-            all()
-
-    def ethernet_card_create(self, values):
-        ethernet_card_ref = self.ethernet_card_dto_class()
-        ethernet_card_ref.update(values)
-        ethernet_card_ref.save(session=self._session)
-        return ethernet_card_ref
-
-    def ethernet_card_update(self, ethernet_card_id, values):
-        with self._session.begin():
-            ethernet_card_ref = self.ethernet_card_get(ethernet_card_id)
-            ethernet_card_ref.update(values)
-            ethernet_card_ref.save(session=self._session)
-
-    def ethernet_card_delete(self, id):
-        with self._session.begin():
-            ethernet_card_ref = self.ethernet_card_get(id)
-            ethernet_card_ref.delete(session=self._session)
-
-
-class NetworkDataAccess(DataAccess):
-    """A Data Access Object to access networks.
-    """
-
-    network_dto_class = Network
-
-    def network_get(self, id):
-        result = self._session.query(self.network_dto_class).\
-            filter_by(deleted=False).\
-            filter_by(id=id).\
-            first()
-
-        if not result:
-            raise exception.NotFound(_("No network with id %s") % id)
-
-        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).\
-            first()
-
-        if not result:
-            raise exception.NotFound(_('No network for bridge %s') % bridge)
-
-        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).\
-            filter_by(ethernet_card_id=ethernet_card_id).\
-            filter_by(deleted=False).\
-            first()
-        if not rv:
-            raise exception.NotFound(_('No network for ethernet card %s') % 
-                                     ethernet_card_id)
-        return rv
-
-    def host_get_networks(self, host):
-        with self._session.begin():
-            return self._session.query(self.network_dto_class).\
-                filter_by(deleted=False).\
-                filter_by(host=host).\
-                all()
-
-    def network_get_all(self):
-        return self._session.query(self.network_dto_class).\
-            filter_by(deleted=self._can_read_deleted).\
-            all()
-
-    def network_create(self, values):
-        network_ref = self.network_dto_class()
-        network_ref.update(values)
-        network_ref.save(session=self._session)
-        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:
-            return None
-
-    def network_update(self, network_id, values):
-        with self._session.begin():
-            network_ref = self.network_get(network_id)
-            network_ref.update(values)
-            network_ref.save(session=self._session)
-
-    def network_delete(self, id):
-        with self._session.begin():
-            network_ref = self.network_get(id)
-            network_ref.delete(session=self._session)
-
-
-class IpAddressDataAccess(DataAccess):
-    """A Data Access Object to access IP addresses.
-    """
-
-    ip_address_dto_class = IpAddress
-
-    def ip_address_get(self, id):
-        result = self._session.query(self.ip_address_dto_class).\
-            filter_by(deleted=False).\
-            filter_by(id=id).\
-            first()
-
-        if not result:
-            raise exception.NotFound(_("No ip address with id %s") % id)
-
-        return result
-
-    def ip_address_get_by_ethernet_card(self, ethernet_card_id):
-        result = self._session.query(self.ip_address_dto_class).\
-            filter_by(deleted=False).\
-            filter_by(ethernet_card_id=ethernet_card_id).\
-            first()
-        return result
-
-    def ip_address_get_all(self):
-        return self._session.query(self.ip_address_dto_class).\
-            filter_by(deleted=self._can_read_deleted).\
-            all()
-
-    def ip_address_create(self, values):
-        ip_address_ref = self.ip_address_dto_class()
-        ip_address_ref.update(values)
-        ip_address_ref.save(session=self._session)
-        return ip_address_ref
-
-    def ip_address_update(self, ip_address_id, values):
-        with self._session.begin():
-            ip_address_ref = self.ip_address_get(ip_address_id)
-            ip_address_ref.update(values)
-            ip_address_ref.save(session=self._session)   
-
-    def ip_address_delete(self, id):
-        with self._session.begin():
-            ip_address_ref = self.ip_address_get(id)
-            ip_address_ref.delete(session=self._session)
-
-    def ip_address_get_by_address(self, address):
-        result = self._session.query(self.ip_address_dto_class).\
-                         filter_by(address=address).\
-                         filter_by(deleted=self._can_read_deleted).\
-                         options(joinedload('network')).\
-                         options(joinedload('ethernet_card')).\
-                         first()
-        if not result:
-            raise exception.NotFound(_('No fixed ip for address %s') % address)
-    
-        return result
-
-    def ip_address_disassociate(self, address):
-        with self._session.begin():
-            ip_address_ref = self.ip_address_get_by_address(context, address,
-                                     session=self._session)
-            ip_address_ref.ethernet_card = None
-            ip_address.save(session=self._session)
-
-
-class FlatNetworkDataAccess(EthernetCardDataAccess, NetworkDataAccess,
-                            IpAddressDataAccess):
-    """A Data Access Object to access all data for the flat network service.
-
-    Also access IP address associations.
-    """
-
-    def ip_address_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.ip_address_dto_class.network_id == network_id,
-                self.ip_address_dto_class.network_id == None)
-            ip_ref = self._session.query(self.ip_address_dto_class).\
-                filter(network_or_none).\
-                filter_by(reserved=False).\
-                filter_by(deleted=False).\
-                filter_by(ethernet_card=None).\
-                with_lockmode('update').\
-                first()
-            if not ip_ref:
-                raise nova_db.NoMoreAddresses()
-            if not ip_ref.network:
-                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

=== removed file 'nova/network/flat/db/sqlalchemy/session.py'
--- nova/network/flat/db/sqlalchemy/session.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/db/sqlalchemy/session.py	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-Session Handling for SQLAlchemy backend
-"""
-
-from sqlalchemy import create_engine
-from sqlalchemy import pool
-from sqlalchemy.orm import sessionmaker
-
-from nova import exception
-from nova import flags
-
-FLAGS = flags.FLAGS
-flags.DEFINE_integer('ns_flat_sql_idle_timeout',
-                     3600,
-                     'timeout for idle sql database connections')
-flags.DEFINE_string('ns_flat_sql_connection',
-              'sqlite:///$state_path/nova_flat_network.sqlite',
-              'connection string for flat network sql database')
-
-_FLAT_NETWORK_ENGINE = None
-_FLAT_NETWORK_MAKER = None
-
-def get_session(autocommit=True, expire_on_commit=False):
-    """Helper method to grab session"""
-    global _FLAT_NETWORK_ENGINE
-    global _FLAT_NETWORK_MAKER
-    if not _FLAT_NETWORK_MAKER:
-        if not _FLAT_NETWORK_ENGINE:
-            kwargs = {'pool_recycle': FLAGS.ns_flat_sql_idle_timeout,
-                      'echo': False}
-
-            if FLAGS.ns_flat_sql_connection.startswith('sqlite'):
-                kwargs['poolclass'] = pool.NullPool
-
-            _FLAT_NETWORK_ENGINE = create_engine(
-                                    FLAGS.ns_flat_sql_connection,
-                                    **kwargs)            
-            
-        _FLAT_NETWORK_MAKER = (sessionmaker(bind=_FLAT_NETWORK_ENGINE,
-                               autocommit=autocommit,
-                               expire_on_commit=expire_on_commit))
-
-    session = _FLAT_NETWORK_MAKER()
-    session.query = exception.wrap_db_error(session.query)
-    session.flush = exception.wrap_db_error(session.flush)
-    return session

=== removed file 'nova/network/flat/network.py'
--- nova/network/flat/network.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat/network.py	1970-01-01 00:00:00 +0000
@@ -1,61 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-from nova import context
-from nova import flags
-from nova import manager
-from nova import utils
-
-from nova.network.flat.db import manager as db_manager
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_network_driver', 'nova.network.linux_net',
-                    'Driver to use for network creation')
-flags.DEFINE_string('ns_flat_dns', '8.8.4.4',
-                    'Dns for simple network')
-
-class NetworkService(manager.Manager):
-
-    def __init__(self, network_driver=None, *args, **kwargs):
-        """Initializes flat network service."""
-        if not network_driver:
-            network_driver = FLAGS.ns_flat_network_driver
-        self.driver = utils.import_object(network_driver)
-        kwargs['db_driver'] = 'nova.network.flat.db.api' 
-        super(NetworkService, self).__init__(*args, **kwargs)
-
-    def init_host(self):
-        """Do any initialization that needs to be run if this is a
-        standalone service.
-        """
-        ctxt = context.get_admin_context()
-        for network in self.db.host_get_networks(ctxt, self.host):
-            self.set_network_host(ctxt, network['id'])
-
-    def set_network_host(self, context, network_id):
-        """Called when this host becomes the host for a network."""
-        net = {}
-        net['dns'] = FLAGS.ns_flat_dns
-        net['host'] = self.host
-        self.db.network_update(context, network_id, net)
-        return self.host
-
-    def allocate_fixed_ips(self, context, vnic_ids):
-        """Gets a fixed ip from the pool."""
-        for vnic_id in vnic_ids:
-           db_manager.bind_ip_to_ethernet_card(context, vnic_id)
-

=== removed directory 'nova/network/flat_dhcp'
=== removed file 'nova/network/flat_dhcp/__init__.py'
--- nova/network/flat_dhcp/__init__.py	2011-03-30 10:33:12 +0000
+++ nova/network/flat_dhcp/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-from zope import interface
-
-from nova.network import service
-from nova.network.flat_dhcp.compute import NetworkAgentService
-from nova.network.flat_dhcp.api import NetworkApiService
-from nova.network.flat_dhcp.api.openstack import NetworkOpenStackApiService
-
-class NetworkServiceFactory(object):
-    """Factory for network services"""
-
-    interface.implements(service.INetworkServiceFactory)
-    
-    def get_api_service(self):
-        """Gets the API service for this plugin."""
-        return NetworkApiService()
-    
-    def get_os_api_service(self):
-        """Gets OS API service for this plugin."""
-        return NetworkOpenStackApiService()
-    
-    def get_net_agent(self):
-        """Gets the net agent for this plugin."""
-        return NetworkAgentService()
-

=== removed directory 'nova/network/flat_dhcp/api'
=== removed file 'nova/network/flat_dhcp/api/__init__.py'
--- nova/network/flat_dhcp/api/__init__.py	2011-03-30 10:11:03 +0000
+++ nova/network/flat_dhcp/api/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.
-from zope import interface
-
-from nova.network import service
-from nova.network.flat_dhcp.db import api as db_api
-from nova.network.flat_dhcp.db import manager as db_manager
-
-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.
-
-        Returns:
-           The ID of the new VNIC.
-        """
-        # Create a new VNIC
-        vnic = db_manager.ethernet_card_create_with_random_mac(context)
-        return vnic.id
-    
-    def get_project_vpn_address_and_port(self, _context, _project_id):
-        """Does not apply."""
-        return (None, None)

=== removed directory 'nova/network/flat_dhcp/api/openstack'
=== removed file 'nova/network/flat_dhcp/api/openstack/__init__.py'
--- nova/network/flat_dhcp/api/openstack/__init__.py	2011-03-31 06:43:59 +0000
+++ nova/network/flat_dhcp/api/openstack/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,44 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-# Copyright (c) 2011 NTT.
-# 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.
-from zope import interface
-
-from nova.network import service
-from nova.network.flat_dhcp.api.openstack import networks    
-from nova.network.flat_dhcp.api.openstack import ports
-from nova.network.flat_dhcp.api.openstack import virtual_nics
-
-class NetworkOpenStackApiService(object):
-    """OpenStack API service object for this plugin."""
-
-    interface.implements(service.INetworkOpenStackApiService)
-
-    def set_routes(self, route_map):
-        """Generic API method to set up all the routes.
-        
-        Args:
-           route_map: NetworkServiceRouteMap object to add the routes to.
-        """
-        # Set up VNIC
-        route_map.resource("vnics", "/vnics",
-                           controller=virtual_nics.Controller())
-    
-        # Set up networks  
-        route_map.resource("networks", "/networks",
-                           controller=networks.Controller())
-    
-        # Set up ports
-        route_map.resource("ports", "/ports", 
-                           controller=ports.Controller())

=== removed file 'nova/network/flat_dhcp/api/openstack/networks.py'
--- nova/network/flat_dhcp/api/openstack/networks.py	2011-03-16 18:03:44 +0000
+++ nova/network/flat_dhcp/api/openstack/networks.py	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
-# 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.
-from webob import exc
-
-from nova import exception
-from nova import wsgi
-from nova.api.openstack import faults
-from nova.db import base
-from nova.network.flat_dhcp import common
-from nova.network.flat_dhcp import db
-from nova.network.flat_dhcp.db import manager
-
-class Controller(wsgi.Controller):
-    """ The Networks API controller for the OpenStack API """
-    
-    def __init__(self):
-        super(Controller, self).__init__()
-
-    def create(self, req):
-        """ Creates a new network. """        
-        env = self._deserialize(req.body, req.get_content_type())
-        if not env:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-
-        label = env['label'] if 'label' in env else 'public'
-        networks = manager.network_create(req.environ['nova.context'], 
-                                          env['cidr'], 
-                                          int(env['num_networks']),
-                                          int(env['network_size']),
-                                          env['cidr_v6'],
-                                          label)
-        items = [common.filter_keys(item, ('id', 'cidr')) 
-                 for item in networks] 
-        return dict(ids=items)
-    
-    def update(self, req, id):
-        """Updates a network."""
-        env = self._deserialize(req.body, req.get_content_type())
-        if not env:
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        
-        # Currently only host can be updated.
-        if 'host' in env:
-            try:
-                manager.network_update_host(req.environ['nova.context'], id, 
-                                            env['host'])
-            except exception.NotFound:
-                return faults.Fault(exc.HTTPNotFound())
-
-        return exc.HTTPNoContent()
-    
-    def show(self, req, id):
-        """ Gets the network with ID given """
-        try:
-            network = db.api.network_get(req.environ['nova.context'], id)
-            return dict(id=network.id, cidr=network.cidr)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-
-    def delete(self, req, id):
-        """ Destroys a network """
-        try:
-            db.api.network_delete(req.environ['nova.context'], id)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()

=== removed file 'nova/network/flat_dhcp/api/openstack/ports.py'
--- nova/network/flat_dhcp/api/openstack/ports.py	2011-03-31 06:43:59 +0000
+++ nova/network/flat_dhcp/api/openstack/ports.py	1970-01-01 00:00:00 +0000
@@ -1,35 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-from nova import wsgi
-from nova.api.openstack import common as nova_common
-from nova.api.openstack import faults
-from nova.network.flat_dhcp import common
-from nova.network.flat_dhcp import db
-
-class Controller(wsgi.Controller):
-    """ The Ports API controller for the OpenStack API """
-    
-    def __init__(self):
-        super(Controller, self).__init__()
-    
-    def index(self, req):
-        """Return all port/IPs in brief"""
-        items = db.api.fixed_ip_get_all(req.environ['nova.context'])
-        items = nova_common.limited(items, req)
-        items = [common.filter_keys(item, ('id', 'address')) for item in items]
-        return dict(ports=items)

=== removed file 'nova/network/flat_dhcp/api/openstack/virtual_nics.py'
--- nova/network/flat_dhcp/api/openstack/virtual_nics.py	2011-03-31 06:43:59 +0000
+++ nova/network/flat_dhcp/api/openstack/virtual_nics.py	1970-01-01 00:00:00 +0000
@@ -1,68 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-from webob import exc
-
-from nova.api.openstack import common as nova_common
-from nova import exception
-from nova import wsgi
-from nova.api.openstack import faults
-from nova.db import base
-from nova.network.flat_dhcp import common
-from nova.network.flat_dhcp import db
-from nova.network.flat_dhcp.db import manager
-
-class Controller(wsgi.Controller):
-    """ The Virtual NICs API controller for the OpenStack API """
-    
-    def __init__(self):
-        super(Controller, self).__init__()
-
-    def index(self, req):
-        """Return all ethernet cards in brief"""
-        items = db.api.ethernet_card_get_all(req.environ['nova.context'])
-        items = nova_common.limited(items, req)
-        items = [common.filter_keys(item, ('id', 'mac_address')) 
-                 for item in items]
-        return dict(ethernet_cards=items)        
-    
-    def create(self, req):
-        """ Creates a new ethernet card. """
-        ethernet_card = manager.ethernet_card_create_with_random_mac(
-                            req.environ['nova.context'])
-        return dict(id=ethernet_card.id)
- 
-    def update(self, req, id):
-        """Update an ethernet card"""
-        return exc.HTTPNoContent()
-    
-    def show(self, req, id):
-        """ Gets the ethernet card with ID given """
-        try:
-            ethernet_card = db.api.ethernet_card_get(
-                                req.environ['nova.context'], id)
-            return dict(id=ethernet_card.id,
-                        mac_address=ethernet_card.mac_address)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-
-    def delete(self, req, id):
-        """ Destroys an ethernet card """
-        try:
-            db.api.ethernet_card_delete(req.environ['nova.context'], id)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-        return exc.HTTPAccepted()

=== removed file 'nova/network/flat_dhcp/common.py'
--- nova/network/flat_dhcp/common.py	2011-03-31 09:36:36 +0000
+++ nova/network/flat_dhcp/common.py	1970-01-01 00:00:00 +0000
@@ -1,39 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-# 
-#   Common utility methods and classes are defined here.
-# 
-
-def filter_keys(item, keys):
-    """
-    Filters all model attributes except for keys
-    item is a dict
-    """
-    return dict((k, v) for k, v in item.iteritems() if k in keys)
-
-def get_net_and_mask(cidr):
-    """Gets network IP and netmask from cidr.
-    
-    Args:
-       cidr: network CIDR.
-       
-    Returns:
-       A tuple of network IP address and network mask.
-    """
-    net = IPy.IP(cidr)
-    return str(net.net()), str(net.netmask())
\ No newline at end of file

=== removed file 'nova/network/flat_dhcp/compute.py'
--- nova/network/flat_dhcp/compute.py	2011-03-31 09:36:36 +0000
+++ nova/network/flat_dhcp/compute.py	1970-01-01 00:00:00 +0000
@@ -1,186 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-import socket
-from zope import interface
-
-from nova import flags
-from nova import rpc
-from nova import utils
-from nova.network import service
-from nova.network.flat_dhcp import common
-from nova.network.flat_dhcp.db import api as db_api
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_dhcp_network_host', socket.gethostname(),
-                    'Network host to use for ip allocation in flat modes')
-flags.DEFINE_string('ns_flat_dhcp_network_topic', 'net-dhcp', 
-                    'the topic network nodes listen on')
-flags.DEFINE_string('ns_flat_dhcp_network_bridge', 'br100',
-                    'Bridge for simple network instances')
-flags.DEFINE_bool('ns_flat_dhcp_network_fake_call', False,
-                  'If True, skip using the queue and make local calls')
-flags.DEFINE_string('ns_flat_dhcp_network_agent_driver', 
-                    'nova.network.linux_net',
-                    'Driver to use for network creation')
-flags.DEFINE_string('ns_flat_dhcp_agent_interface', None,
-                    'FlatDhcp will bridge into this interface if set')
-
-def _queue_get_for(topic, physical_node_id):
-    return "%s.%s" % (topic, physical_node_id)
-
-def _get_network_topic(context, **kwargs):
-    """Retrieves the network host for a project on this host"""
-    if FLAGS.stub_network:
-        host = FLAGS.ns_flat_dhcp_network_host
-    else:
-        host = _get_network_host(context)
-    return _queue_get_for(FLAGS.ns_flat_dhcp_network_topic,
-                          host)
-
-def _set_network_host(context, network_id):
-    """Safely sets the host of the network."""
-    db_api.network_update(context,
-                          network_id,
-                          {"host":FLAGS.host,
-                           "dns": FLAGS.ns_flat_dhcp_dns})
-    return FLAGS.host 
-
-def _get_network_host(context):
-    """Get the network host for the current context."""
-    network_ref = db_api.network_get_by_bridge(context,
-                                             FLAGS.ns_flat_dhcp_network_bridge)
-    host = network_ref['host']
-    if not host:
-        topic = _queue_get_for(FLAGS.ns_flat_dhcp_network_topic,
-                               FLAGS.ns_flat_dhcp_network_host)
-        if FLAGS.ns_flat_dhcp_network_fake_call:
-            return _set_network_host(context, network_ref['id'])
-        host = rpc.call(context,
-                        FLAGS.ns_flat_dhcp_network_topic,
-                        {"method": "set_network_host",
-                         "args": {"network_id": network_ref['id']}})
-    return host
-
-class NetworkAgentService(object):
-    """An OpenStack network agent service object."""
-
-    interface.implements(service.INetworkOpenStackApiService)
-
-    def bind_vnics_to_ports(self, 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.          
-        """
-        rpc.call(context,
-                 _get_network_topic(context),
-                 {"method": "allocate_fixed_ips",
-                  "args": {"vnic_ids": vnic_ids}})
-    
-    def setup_compute_network(self, context, vnic_ids): 
-        """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.
-        """
-        driver = utils.import_object(FLAGS.ns_flat_dhcp_network_agent_driver)
-        for vnic_id in vnic_ids:
-            network_ref = db_api.network_get_by_ethernet_card(context, vnic_id)
-            driver.ensure_bridge(network_ref['bridge'],
-                                 FLAGS.ns_flat_dhcp_agent_interface)
-    
-    def teardown_compute_network(self, context, vnic_ids):
-        """Clean up the compute node.
-        
-        Args:
-           context: Nova context needed for DB access.
-           vnic_ids: list of VNIC IDs
-        """
-        for vnic_id in vnic_ids:
-            fixed_ip = vnic_id.get('fixed_ip')
-            if not FLAGS.stub_network and fixed_ip:
-                floating_ips = fixed_ip.get('floating_ips') or []
-    
-                for floating_ip in floating_ips:
-                    address = floating_ip['address']
-                
-                    network_topic = _queue_get_for(context,
-                                         FLAGS.ns_flat_dhcp_network_topic,
-                                         floating_ip['host'])
-                
-                    rpc.cast(context,
-                             network_topic,
-                             {"method": "disassociate_floating_ip",
-                              "args": {"floating_address": address}})
-                
-                address = fixed_ip['address']
-                if address:
-                    # NOTE(vish): Currently, nothing needs to be done on the
-                    #             network node until release. If this changes,
-                    #             we will need to cast here.
-                    db_api.fixed_ip_update(context.elevated(), address,
-                                           {'allocated':False}) 
-    
-    def requires_file_injection(self):
-        """This service does not requires file injection.
-        """
-        return False
-    
-    def get_network_info(self, 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, 
-           dhcp_server, broadcast, dns, ra_server, mac_address,
-           ip_address, bridge, and address_v6
-        """
-        ethernet_card = db_api.ethernet_card_get(context, vnic_id)
-        if not ethernet_card:
-    	    raise ValueError("Invalid vnic ID!")
-    
-        # Get the IP address associated with this VNIC
-        ip_address = db_api.fixed_ip_get_by_ethernet_card(context, 
-    							ethernet_card.id)
-        if not ip_address:
-    	    raise ValueError("VNIC is not mapped to IP!")
-    
-        network = ip_address.network
-        if network['cidr_v6']:
-    	    ipv6_addr = utils.to_global_ipv6(network['cidr_v6'],
-    					   ethernet_card['mac_address'])
-        else:
-    	    ipv6_addr = None
-    
-        net, mask = common.get_net_and_mask(network['cidr'])
-        return dict(mac_address=ethernet_card['mac_address'],
-    		ip_address=ip_address['address'], bridge=network['bridge'],
-    		cidr=network['cidr'], netmask=network['netmask'],
-    		gateway=network['gateway'], broadcast=network['broadcast'],
-    		dns=network['dns'], dhcp_server=network['gateway'], 
-    		cidr_v6=network['cidr_v6'], address_v6=ipv6_addr, 
-    		ra_server=network['ra_server'], netmask_v6=None, 
-            gateway_v6=None, net=net, mask=mask) 
-    		

=== removed directory 'nova/network/flat_dhcp/db'
=== removed file 'nova/network/flat_dhcp/db/__init__.py'
--- nova/network/flat_dhcp/db/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/db/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-DB abstraction for Nova
-"""
-

=== removed file 'nova/network/flat_dhcp/db/api.py'
--- nova/network/flat_dhcp/db/api.py	2011-03-24 15:46:07 +0000
+++ nova/network/flat_dhcp/db/api.py	1970-01-01 00:00:00 +0000
@@ -1,219 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-Defines interface for DB access.
-
-The underlying driver is loaded as a :class:`LazyPluggable`.
-"""
-from nova import flags
-from nova import utils
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_dhcp_db_backend', 
-                    'sqlalchemy',
-                    'Default backend to use for SQL.')
-flags.DEFINE_string('ns_flat_dhcp_sqlalchemy_api', 
-                    'nova.network.flat_dhcp.db.sqlalchemy.ap',
-                    'SQL Alchemy module to use.')
-
-IMPL = utils.LazyPluggable(FLAGS['ns_flat_dhcp_db_backend'],
-        sqlalchemy='nova.network.flat_dhcp.db.sqlalchemy.api')
-
-###################
-
-def ethernet_card_get(context, id):
-    """Get ethernet card by id."""
-    return IMPL.dao_factory.get_dao(context).\
-        ethernet_card_get(id)
-
-def ethernet_card_create(context, values):
-    """Create a new ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
-        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()
-
-def ethernet_card_update(context, ethernet_card_id, values):
-    """Update ethernet card.""" 
-    return IMPL.dao_factory.get_dao(context).\
-        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).\
-        ethernet_card_delete(ethernet_card_id)
-
-def network_get(context, id):
-    """Get network by id."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_get(id)
-
-def network_get_by_ethernet_card(context, ethernet_card_id):
-    """Get network by ethernet card."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_get_by_ethernet_card(ethernet_card_id)
-
-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).\
-        network_get_associated_fixed_ips(network_id)
-
-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).\
-        network_get_by_bridge(bridge)
-    
-def host_get_networks(context, host):
-    """Get networks for a given host."""
-    return IMPL.dao_factory.get_dao(context).\
-        host_get_networks(host)
-
-def network_create(context, values):
-    """Create a new network."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_create(values)
-
-def network_create_safe(context, values):
-    """Create a new network.  Returns None when there is an exception"""
-    return IMPL.dao_factory.get_dao(context).\
-        network_create_safe(values)
-
-def network_get_all(context):
-    """Get all networks."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_get_all()
-
-def network_update(context, network_id, values):
-    """Update network.""" 
-    return IMPL.dao_factory.get_dao(context).\
-        network_update(network_id, values)
-
-def network_delete(context, network_id):
-    """Delete network."""
-    return IMPL.dao_factory.get_dao(context).\
-        network_delete(network_id)
-
-def fixed_ip_create(context, values):
-    """Create a new fixed IP address."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_create(values)
-
-def fixed_ip_get(context, fixed_ip_id):
-    """Gets fixed IP with ID."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_get(fixed_ip_id)
-
-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)
-
-def fixed_ip_get_all(context):
-    """Get all the fixed IP addresses."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_get_all()
-
-def fixed_ip_update(context, fixed_ip_id, values):
-    """Update fixed IP."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_update(fixed_ip_id, values)
-
-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)
-
-def floating_ip_get_all_by_host(context, host):
-    """Get all the floating IPs for a host."""
-    return IMPL.dao_factory.get_dao(context).\
-        floating_ip_get_all_by_host(host)
-
-def floating_ip_allocate_address(context, host, project_id):
-    """Allocate free floating ip and return the address.
-
-    Raises if one is not available.
-
-    """
-    return IMPL.dao_factory.get_dao(context).\
-        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).\
-        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).\
-        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).\
-        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).\
-        floating_ip_destroy(address)
-
-def floating_ip_disassociate(context, address):
-    """Disassociate an floating ip from a fixed ip by address.
-
-    Returns the address of the existing fixed ip.
-
-    """
-    return IMPL.dao_factory.get_dao(context).\
-        floating_ip_disassociate(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).\
-        floating_ip_fixed_ip_associate(floating_address, fixed_address)
-
-def floating_ip_get_all(context):
-    """Get all floating ips."""
-    return IMPL.dao_factory.get_dao(context).\
-        floating_ip_get_all()
-
-def floating_ip_get_all_by_project(context, project_id):
-    """Get all floating ips by project."""
-    return IMPL.dao_factory.get_dao(context).\
-        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)
-
-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).\
-        floating_ip_update(address, values)
-
-def fixed_ip_disassociate(context, fixed_ip_id):
-    """Removes reference to ethernet card from IP."""
-    return IMPL.dao_factory.get_dao(context).\
-        fixed_ip_disassociate(fixed_ip_id)
-
-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).\
-        fixed_ip_associate_pool(network_id, ethernet_card_id)

=== removed file 'nova/network/flat_dhcp/db/manager.py'
--- nova/network/flat_dhcp/db/manager.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/db/manager.py	1970-01-01 00:00:00 +0000
@@ -1,129 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-"""
-Wrapper APIs for DB models should be defined here.
-"""
-import collections
-import IPy
-import math
-
-from nova import exception
-from nova import flags
-from nova import utils
-
-from nova.network.flat_dhcp.db import api
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_dhcp_bridge',
-                    'br100',
-                    'Bridge for simple network instances')
-flags.DEFINE_string('ns_flat_dhcp_dns', '8.8.4.4',
-                    'Dns for simple network')
-
-BOTTOM_RESERVED_IPS = 2
-TOP_RESERVED_IPS = 1
-
-def _create_fixed_ips(context, network_id):
-    """Create all fixed ips for network."""
-    network_ref = api.network_get(context, network_id)
-    net = IPy.IP(network_ref['cidr'])
-    num_ips = len(net)
-    for index in range(num_ips):
-        address = str(net[index])
-        if index < BOTTOM_RESERVED_IPS or num_ips - index < TOP_RESERVED_IPS:
-            reserved = True
-        else:
-            reserved = False
-
-        api.fixed_ip_create(context, 
-                            {'network_id': network_id,
-                             'address': address,
-                             'reserved': reserved})
-
-def network_create(context, cidr, num_networks, network_size,
-           cidr_v6, label, *args, **kwargs):
-    """Create networks based on parameters."""
-    fixed_net = IPy.IP(cidr)
-    fixed_net_v6 = IPy.IP(cidr_v6)
-    significant_bits_v6 = 64
-    networks = []
-    count = 1
-    for index in range(num_networks):
-        start = index * network_size
-        significant_bits = 32 - int(math.log(network_size, 2))
-        cidr = "%s/%s" % (fixed_net[start], significant_bits)
-        project_net = IPy.IP(cidr)
-        net = {}
-        net['bridge'] = FLAGS.ns_flat_dhcp_bridge
-        net['cidr'] = cidr
-        net['netmask'] = str(project_net.netmask())
-        net['gateway'] = str(project_net[1])
-        net['broadcast'] = str(project_net.broadcast())
-        net['dns'] = FLAGS.ns_flat_dhcp_dns
-        net['dhcp_start'] = str(project_net[2])
-        if num_networks > 1:
-            net['label'] = "%s_%d" % (label, count)
-        else:
-            net['label'] = label
-        count += 1
-        
-        if(FLAGS.use_ipv6):
-            cidr_v6 = "%s/%s" % (fixed_net_v6[0], significant_bits_v6)
-            net['cidr_v6'] = cidr_v6
-
-        network_ref = api.network_create_safe(context, net)
-
-        networks.append(network_ref)
-        if network_ref:
-            _create_fixed_ips(context, network_ref['id'])
-
-    return networks
-
-def allocate_ip(context, ethernet_card_id, *args, **kwargs):
-    """Gets an IP from the pool."""
-    network_ref = api.network_get_by_bridge(context,
-                                            FLAGS.ns_flat_dhcp_bridge)
-    ip = api.fixed_ip_associate_pool(context.elevated(),
-                                     network_ref['id'],
-                                     ethernet_card_id)
-    api.fixed_ip_update(context, ip.id, {'allocated': True})
-    return ip
-
-def bind_ip_to_ethernet_card(context, ethernet_card_id):
-    """Assigns IP to ethernet card."""
-    
-    # Get the ethernet card
-    ethernet_card = api.ethernet_card_get(context, ethernet_card_id)
-    # TODO: Throw a better exception.
-    if not ethernet_card:
-        raise ValueError("There is not VNIC with ID %s" % ethernet_card_id)
-
-    ip_address = api.fixed_ip_get_by_ethernet_card(context, 
-                                                   ethernet_card_id)
-    # Check to see if this ethernet card does not have IP allocated.
-    if not ip_address:
-        ip_address = allocate_ip(context, ethernet_card_id)
-
-    return ip_address
-
-def ethernet_card_create_with_random_mac(context):
-    """Creates a new ethernet card"""
-    mac_address = utils.generate_mac()
-    return api.ethernet_card_create(context, dict(mac_address=mac_address))
-
-

=== removed directory 'nova/network/flat_dhcp/db/sqlalchemy'
=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/__init__.py'
--- nova/network/flat_dhcp/db/sqlalchemy/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.

=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/api.py'
--- nova/network/flat_dhcp/db/sqlalchemy/api.py	2011-03-24 21:53:30 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/api.py	1970-01-01 00:00:00 +0000
@@ -1,62 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-Implementation of SQLAlchemy backend.
-"""
-
-from sqlalchemy import or_
-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.db.sqlalchemy import api as flat_api
-from nova.network.flat_dhcp.db.sqlalchemy import models
-from nova.network.flat_dhcp.db.sqlalchemy.session import get_session
-
-
-class DefaultSessionFlatDhcpNetworkDataAccessFactory(object):
-    """A DAO factory that lazily uses the default session.
-
-    This factory uses the default session for the flat DHCP network
-    service, which it creates lazily when creating the first DAO.
-    """
-
-    def __init__(self):
-        self._dao_cache = flat_api.DataAccessCache(
-            models.FlatDhcpNetworkDataAccess)
-        self._session = None
-
-    def get_session(self):
-        if self._session is None:
-            self._session = get_session()
-        return self._session
-
-    def get_dao(self, context):
-        """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.
-        """
-        return self._dao_cache.get_dao(context, self.get_session())
-
-
-dao_factory = DefaultSessionFlatDhcpNetworkDataAccessFactory()

=== removed directory 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo'
=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/README'
--- nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/README	2011-03-15 15:01:10 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/README	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-This is a database migration repository.
-
-More information at
-http://code.google.com/p/sqlalchemy-migrate/

=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/__init__.py'
--- nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.

=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/manage.py'
--- nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/manage.py	2011-03-15 15:01:10 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/manage.py	1970-01-01 00:00:00 +0000
@@ -1,4 +0,0 @@
-#!/usr/bin/env python
-from migrate.versioning.shell import main
-if __name__ == '__main__':
-    main(debug='False', repository='.')

=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/migrate.cfg'
--- nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/migrate.cfg	2011-03-15 15:01:10 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/migrate.cfg	1970-01-01 00:00:00 +0000
@@ -1,20 +0,0 @@
-[db_settings]
-# Used to identify which repository this database is versioned under.
-# You can use the name of your project.
-repository_id=nova_network_flat_dhcp
-
-# The name of the database table used to track the schema version.
-# This name shouldn't already be used by your project.
-# If this is changed once a database is under version control, you'll need to 
-# change the table name in each database too. 
-version_table=migrate_version
-
-# When committing a change script, Migrate will attempt to generate the 
-# sql for all supported databases; normally, if one of them fails - probably
-# because you don't have that database installed - it is ignored and the 
-# commit continues, perhaps ending successfully. 
-# Databases in this list MUST compile successfully during a commit, or the 
-# entire commit will fail. List the databases your application will actually 
-# be using to ensure your updates to that database work properly.
-# This must be a list; example: ['postgres','sqlite']
-required_dbs=[]

=== removed directory 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/versions'
=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/versions/001_diablo.py'
--- nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/versions/001_diablo.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/versions/001_diablo.py	1970-01-01 00:00:00 +0000
@@ -1,137 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-meta = MetaData()
-
-#
-# New Tables
-#
-fixed_ips = Table('fixed_ips', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('address',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('network_id', Integer(), ForeignKey('networks.id'),
-               nullable=True),
-        Column('allocated', Boolean(create_constraint=True, name=None)),
-        Column('leased', Boolean(create_constraint=True, name=None)),
-        Column('reserved', Boolean(create_constraint=True, name=None)),
-        Column("addressV6",
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column("netmaskV6",
-               String(length=3, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column("gatewayV6",
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('ethernet_card_id', Integer(), ForeignKey('ethernet_cards.id'),
-               nullable=True),
-        )
-
-floating_ips = Table('floating_ips', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('address',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('fixed_ip_id',
-               Integer(),
-               ForeignKey('fixed_ips.id'),
-               nullable=True),
-        Column('project_id',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('host',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        )
-
-ethernet_cards = Table(
-        'ethernet_cards', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True, nullable=False),
-        Column('mac_address', String(255), nullable=False),
-        )
-
-networks = Table(
-        'networks', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(),  primary_key=True),
-        Column('cidr', String(255)),
-        Column('netmask', String(255)),
-        Column('bridge', String(255)),
-        Column('gateway', String(255)),
-        Column('broadcast', String(255)),
-        Column('dns',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('dhcp_start',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('cidr_v6',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('ra_server',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)), 
-        Column('label',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False)),
-        Column('host', String(255)),
-        )
-
-def upgrade(migrate_engine):
-    meta.bind = migrate_engine
-
-    for table in (ethernet_cards, networks, fixed_ips, floating_ips):
-        try:    
-            table.create()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while creating table')
-            raise
-
-def downgrade(migrate_engine):
-    meta.bind = migrate_engine
-
-    for table in (floating_ips, fixed_ips, networks, ethernet_cards):
-        try:    
-            table.drop()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while dropping table')
-            raise
-

=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/versions/__init__.py'
--- nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/versions/__init__.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/migrate_repo/versions/__init__.py	1970-01-01 00:00:00 +0000
@@ -1,16 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.

=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/models.py'
--- nova/network/flat_dhcp/db/sqlalchemy/models.py	2011-03-24 21:53:30 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/models.py	1970-01-01 00:00:00 +0000
@@ -1,354 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-SQLAlchemy models for flat DHCP network service data.
-"""
-
-from sqlalchemy.orm import joinedload_all
-from sqlalchemy.orm import relationship, backref
-from sqlalchemy import Column, Boolean, Integer, String
-from sqlalchemy import ForeignKey
-from sqlalchemy.ext.declarative import declarative_base
-
-from nova.db.sqlalchemy.models import NovaBase
-from nova.network.flat.db.sqlalchemy import models as flat_models
-
-
-BASE = declarative_base()
-
-
-# ----------------------
-# Data Transfer Objects.
-# ----------------------
-
-class EthernetCard(BASE, NovaBase):
-    """Represents an ethernet card."""
-    __tablename__ = 'ethernet_cards'
-    id = Column(Integer, primary_key=True)
-    mac_address = Column(String(255), nullable=False, unique=True)
-
-class Network(BASE, NovaBase):
-    """Represents a simple IP network with DHCP service."""
-    __tablename__ = 'networks'
-    id = Column(Integer, primary_key=True)
-    cidr = Column(String(255))
-    netmask = Column(String(255))
-    bridge = Column(String(255))
-    gateway = Column(String(255))
-    broadcast = Column(String(255))
-    dns = Column(String(255))
-    cidr_v6 = Column(String(255), unique=True)
-    host = Column(String(255))  # , ForeignKey('hosts.id'))
-
-    dhcp_start = Column(String(255))
-    ra_server = Column(String(255))
-    label = Column(String(255))
-
-    
-class FixedIp(BASE, NovaBase):
-    """Represents a fixed ip for an instance."""
-    __tablename__ = 'fixed_ips'
-    id = Column(Integer, primary_key=True)
-    address = Column(String(255))
-    network_id = Column(Integer, ForeignKey('networks.id'), nullable=True)
-    network = relationship(Network, backref=backref('fixed_ips'))
-    ethernet_card_id = Column(Integer, ForeignKey('ethernet_cards.id'))
-    ethernet_card = relationship(EthernetCard,
-                                 backref=backref('fixed_ips'))
-    allocated = Column(Boolean, default=False)
-    leased = Column(Boolean, default=False)
-    reserved = Column(Boolean, default=False)
-    addressV6 = Column(String(255))
-    netmaskV6 = Column(String(3))
-    gatewayV6 = Column(String(255))
-
-
-class FloatingIp(BASE, NovaBase):
-    """Represents a floating ip that dynamically forwards to a fixed ip."""
-    __tablename__ = 'floating_ips'
-    id = Column(Integer, primary_key=True)
-    address = Column(String(255))
-    fixed_ip_id = Column(Integer, ForeignKey('fixed_ips.id'), nullable=True)
-    fixed_ip = relationship(FixedIp,
-                            backref=backref('floating_ips'),
-                            foreign_keys=fixed_ip_id,
-                            primaryjoin='and_('
-                                'FloatingIp.fixed_ip_id == FixedIp.id,'
-                                'FloatingIp.deleted == False)')
-    project_id = Column(String(255))
-    host = Column(String(255))  # , ForeignKey('hosts.id'))    
-
-
-# ----------------------
-# Data Access Objects.
-# ----------------------
-
-class EthernetCardDataAccess(flat_models.EthernetCardDataAccess):
-    """A Data Access Object to access networks.
-    """
-
-    ethernet_card_dto_class = EthernetCard
-
-
-class NetworkDataAccess(flat_models.NetworkDataAccess):
-    """A Data Access Object to access networks.
-    """
-
-    network_dto_class = Network
-
-
-class FixedIpDataAccess(flat_models.DataAccess):
-    """A Data Access Object to access fixed IPs.
-    """
-
-    fixed_ip_dto_class = FixedIp
-
-    def fixed_ip_create(self, values):
-        fixed_ip_ref = self.fixed_ip_dto_class()
-        fixed_ip_ref.update(values)
-        fixed_ip_ref.save(session=self._session)
-        return fixed_ip_ref['address']
-
-    def fixed_ip_update(self, fixed_ip_id, values):
-        with self._session.begin():
-            fixed_ip_ref = self.fixed_ip_get(fixed_ip_id)
-            fixed_ip_ref.update(values)
-            fixed_ip_ref.save(session=self._session)
-
-    def fixed_ip_get(self, fixed_ip_id):
-        result = self._session.query(self.fixed_ip_dto_class).\
-            filter_by(deleted=False).\
-            filter_by(id=fixed_ip_id).\
-            first()
-
-        if not result:
-            raise exception.NotFound(_("No Fixed IP with id %s") % id)
-
-        return result
-
-    def fixed_ip_get_all(self):
-        result = self._session.query(self.fixed_ip_dto_class).all()
-        if not result:
-            raise exception.NotFound(_('No fixed ips defined'))
-
-        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).\
-            filter(self.fixed_ip_dto_class.ethernet_card_id != None).\
-            filter_by(deleted=False).\
-            all()
-
-    network_get_associated_ips = network_get_associated_fixed_ips
-
-    def fixed_ip_get_by_address(self, address):
-        result = self._session.query(self.fixed_ip_dto_class).\
-            filter_by(address=address).\
-            filter_by(deleted=self._can_read_deleted).\
-            options(joinedload('network')).\
-            options(joinedload('ethernet_card')).\
-            first()
-        if not result:
-            raise exception.NotFound(_('No fixed ip for address %s') % address)
-
-        return result
-
-    def fixed_ip_disassociate(self, fixed_ip_id):
-        with self._session.begin():
-            fixed_ip_ref = self.fixed_ip_get(fixed_ip_id)
-            fixed_ip_ref.ethernet_card = None
-            fixed_ip_ref.save(session=self._session)
-
-    def fixed_ip_get_by_ethernet_card(self, ethernet_card_id):
-        result = self._session.query(self.fixed_ip_dto_class).\
-            filter_by(ethernet_card_id=ethernet_card_id).\
-            filter_by(deleted=self._can_read_deleted).\
-            first()
-        return result
-
-
-class FloatingIpDataAccess(flat_models.DataAccess):
-    """A Data Access Object to access floating IPs.
-    """
-
-    floating_ip_dto_class = FloatingIp
-
-    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()
-            # 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()
-
-    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['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.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)
-            fixed_ip_ref = floating_ip_ref.fixed_ip
-            if fixed_ip_ref:
-                fixed_ip_address = fixed_ip_ref['address']
-            else:
-                fixed_ip_address = None
-            floating_ip_ref.fixed_ip = None
-            floating_ip_ref.save(session=self._session)
-        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).\
-            options(joinedload_all('fixed_ip.network')).\
-            filter_by(address=address).\
-            filter_by(deleted=self._can_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)
-            for (key, value) in values.iteritems():
-                floating_ip_ref[key] = value
-            floating_ip_ref.save(session=self._session)
-
-    def floating_ip_create(self, values):
-        floating_ip_ref = self.floating_ip_dto_class()
-        floating_ip_ref.update(values)
-        floating_ip_ref.save(session=self._session)
-        return floating_ip_ref
-
-    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)
-            fixed_ip_ref = floating_ip_ref.fixed_ip
-            if fixed_ip_ref:
-                fixed_ip_address = fixed_ip_ref['address']
-            else:
-                fixed_ip_address = None
-            floating_ip_ref.fixed_ip = None
-            floating_ip_ref.save(session=self._session)
-        return fixed_ip_address
-
-    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).\
-                   filter_by(deleted=False).\
-                   all()
-
-
-class FlatDhcpNetworkDataAccess(
-    EthernetCardDataAccess, NetworkDataAccess, FixedIpDataAccess,
-    FloatingIpDataAccess):
-    """A Data Access Object to access all data for the flat DHCP network
-    service.
-
-    Also access fixed IP address associations.
-    """
-
-    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.fixed_ip = fixed_ip_ref
-            floating_ip_ref.save(session=self._session)
-
-    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,
-                self.fixed_ip_dto_class.network_id == None)
-            ip_ref = self._session.query(self.fixed_ip_dto_class).\
-                filter(network_or_none).\
-                filter_by(reserved=False).\
-                filter_by(deleted=False).\
-                filter_by(ethernet_card=None).\
-                with_lockmode('update').\
-                first()
-            if not ip_ref:
-                raise nova_db.NoMoreAddresses()
-            if not ip_ref.network:
-                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

=== removed file 'nova/network/flat_dhcp/db/sqlalchemy/session.py'
--- nova/network/flat_dhcp/db/sqlalchemy/session.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/db/sqlalchemy/session.py	1970-01-01 00:00:00 +0000
@@ -1,63 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-"""
-Session Handling for SQLAlchemy backend
-"""
-
-from sqlalchemy import create_engine
-from sqlalchemy import pool
-from sqlalchemy.orm import sessionmaker
-
-from nova import exception
-from nova import flags
-
-FLAGS = flags.FLAGS
-flags.DEFINE_integer('ns_flat_dhcp_sql_idle_timeout',
-                     3600,
-                     'timeout for idle sql database connections')
-flags.DEFINE_string('ns_flat_dhcp_sql_connection',
-              'sqlite:///$state_path/nova_flat_dhcp_network.sqlite',
-              'connection string for flat DHCP network sql database')
-
-_FLAT_DHCP_NETWORK_ENGINE = None
-_FLAT_DHCP_NETWORK_MAKER = None
-
-def get_session(autocommit=True, expire_on_commit=False):
-    """Helper method to grab session"""
-    global _FLAT_DHCP_NETWORK_ENGINE
-    global _FLAT_DHCP_NETWORK_MAKER
-    if not _FLAT_DHCP_NETWORK_MAKER:
-        if not _FLAT_DHCP_NETWORK_ENGINE:
-            kwargs = {'pool_recycle': FLAGS.ns_flat_dhcp_sql_idle_timeout,
-                      'echo': False}
-
-            if FLAGS.ns_flat_dhcp_sql_connection.startswith('sqlite'):
-                kwargs['poolclass'] = pool.NullPool
-
-            _FLAT_DHCP_NETWORK_ENGINE = create_engine(
-                                    FLAGS.ns_flat_dhcp_sql_connection,
-                                    **kwargs)            
-            
-        _FLAT_DHCP_NETWORK_MAKER = (sessionmaker(
-                               bind=_FLAT_DHCP_NETWORK_ENGINE,
-                               autocommit=autocommit,
-                               expire_on_commit=expire_on_commit))
-
-    session = _FLAT_DHCP_NETWORK_MAKER()
-    session.query = exception.wrap_db_error(session.query)
-    session.flush = exception.wrap_db_error(session.flush)
-    return session

=== removed file 'nova/network/flat_dhcp/dhcp.py'
--- nova/network/flat_dhcp/dhcp.py	2011-03-31 09:36:36 +0000
+++ nova/network/flat_dhcp/dhcp.py	1970-01-01 00:00:00 +0000
@@ -1,80 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-from nova import context
-from nova import flags
-from nova import log as logging
-from nova import rpc
-
-from nova.network.flat_dhcp.network import NetworkService
-
-FLAGS = flags.FLAGS
-
-LOG = logging.getLogger('nova.dhcpbridge-flat-dhcp')
-
-class DHCPEventHandler(object):
-
-    @classmethod
-    def init_leases(cls, interface):
-        """Get the list of hosts for an interface."""
-        ctxt = context.get_admin_context()
-        if FLAGS.fake_rabbit:
-            LOG.debug(_("initializing leases"))
-            return NetworkService().get_dhcp_host_leases(ctxt, interface)
-        else:
-            return rpc.call(ctxt,
-                     "%s.%s" % (FLAGS.ns_flat_dhcp_network_topic, 
-                                FLAGS.host),
-                     {"method": "get_dhcp_host_leases",
-                      "args": {"interface": interface}})
-
-    @classmethod
-    def add_lease(cls, mac, ip_address, _hostname, _interface):
-        """Set the IP that was assigned by the DHCP server."""
-        ctxt = context.get_admin_context()
-        if FLAGS.fake_rabbit:
-            LOG.debug(_("leasing ip"))
-            return NetworkService().lease_fixed_ip(ctxt, mac, ip_address)
-        else:
-            rpc.cast(ctxt,
-                     "%s.%s" % (FLAGS.ns_flat_dhcp_network_topic, 
-                                FLAGS.host),
-                     {"method": "lease_fixed_ip",
-                      "args": {"mac": mac,
-                               "address": ip_address}})
-
-    @classmethod
-    def old_lease(cls, mac, ip_address, hostname, interface):
-        """Update just as add lease."""
-        LOG.debug(_("Adopted old lease or got a change of mac/hostname"))
-        cls.add_lease(mac, ip_address, hostname, interface)
-
-    @classmethod
-    def del_lease(cls, mac, ip_address, _hostname, _interface):
-        """Called when a lease expires."""
-        ctxt = context.get_admin_context()
-        if FLAGS.fake_rabbit:
-            LOG.debug(_("releasing ip"))
-            NetworkService().release_fixed_ip(ctxt, mac, ip_address)
-        else:
-            rpc.cast(ctxt,
-                     "%s.%s" % (FLAGS.ns_flat_dhcp_network_topic, 
-                                FLAGS.host),
-                     {"method": "release_fixed_ip",
-                      "args": {"mac": mac,
-                               "address": ip_address}})
-    

=== removed file 'nova/network/flat_dhcp/network.py'
--- nova/network/flat_dhcp/network.py	2011-03-24 10:27:45 +0000
+++ nova/network/flat_dhcp/network.py	1970-01-01 00:00:00 +0000
@@ -1,255 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# 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.
-
-import collections
-import os
-
-from nova import context
-from nova import flags
-from nova import log as logging
-from nova import manager
-from nova import utils
-from nova.db import api as nova_db_api
-from nova.network.flat_dhcp.db import manager as db_manager
-
-def _bin_file(script):
-    """Return the absolute path to scipt in the bin directory"""
-    return os.path.abspath(os.path.join(__file__, "../../../../bin", script))
-
-FLAGS = flags.FLAGS
-flags.DEFINE_string('ns_flat_dhcp_network_driver', 'nova.network.linux_net',
-                    'Driver to use for network creation')
-flags.DEFINE_string('ns_flat_dhcp_dhcp_driver', 'nova.network.linux_dhcp',
-                    'Driver to use for DHCP')
-flags.DEFINE_string('ns_flat_dhcp_ra_driver', 'nova.network.linux_ra',
-                    'Driver to use for RA')
-flags.DEFINE_string('ns_flat_dhcp_network_dhcp_start', '10.0.0.2',
-                    'Dhcp start for FlatDhcp')
-flags.DEFINE_string('ns_flat_dhcp_interface', None,
-                    'FlatDhcp will bridge into this interface if set')
-flags.DEFINE_string('ns_flat_dhcp_dhcpbridge', 
-                    _bin_file('nova-dhcpbridge-flat-dhcp'),
-                    'location of nova-dhcpbridge')
-flags.DEFINE_string('ns_flat_dhcp_dhcpbridge_flagfile',
-                    '/etc/nova/nova-dhcpbridge.conf',
-                    'location of flagfile for dhcpbridge')
-flags.DEFINE_bool('ns_flat_dhcp_update_dhcp_on_disassociate', False,
-                  'Whether to update dhcp when fixed_ip is disassociated')
-
-LOG = logging.getLogger("nova.net_dhcp")
-
-DhcpHost = collections.namedtuple('DhcpHost', 
-                                'mac_address, hostname, ip_address, timestamp')
-
-class NetworkService(manager.Manager):
-
-    def __init__(self, network_driver=None, dhcp_driver=None, ra_driver=None,
-                 *args, **kwargs):
-        """Initializes flat network service."""
-        if not network_driver:
-            network_driver = FLAGS.ns_flat_dhcp_network_driver
-        if not dhcp_driver:
-            dhcp_driver = FLAGS.ns_flat_dhcp_dhcp_driver
-        if not ra_driver:
-            ra_driver = FLAGS.ns_flat_dhcp_ra_driver
-
-        kwargs['db_driver'] = 'nova.network.flat_dhcp.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)
-        super(NetworkService, self).__init__(*args, **kwargs)
-
-    def init_host(self):
-        """Do any initialization that needs to be run if this is a
-        standalone service.
-        """
-        self.driver.init_host()
-        # Set up networking for the projects for which we're already
-        # the designated network host.
-        ctxt = context.get_admin_context()
-        for network in self.db.host_get_networks(ctxt, self.host):
-            self.set_network_host(ctxt, network['id'])
-        floating_ips = self.db.floating_ip_get_all_by_host(ctxt,
-                                                           self.host)
-        for floating_ip in floating_ips:
-            if floating_ip.get('fixed_ip', None):
-                fixed_address = floating_ip['fixed_ip']['address']
-                # 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.driver.metadata_forward()
-
-    def set_network_host(self, context, network_id):
-        """Called when this host becomes the host for a project."""
-        net = {}
-        net['host'] = self.host
-        net['dhcp_start'] = FLAGS.ns_flat_dhcp_network_dhcp_start
-        self.db.network_update(context, network_id, net)
-
-        network_ref = self.db.network_get(context, network_id)
-        bridge = network_ref['bridge']
-        self.driver.ensure_bridge(bridge,
-                                  FLAGS.ns_flat_dhcp_interface,
-                                  network_ref)
-        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'], 
-                                         hosts,
-                                         dhcp_script=FLAGS.\
-                                                     ns_flat_dhcp_dhcpbridge)
-            if(FLAGS.use_ipv6):
-                self.ra_driver.update_ra(bridge,
-                                         network_ref['cidr_v6'])
-                self.db.network_update(context, network_id,
-                                       {"ra_server":
-                                        utils.get_my_linklocal(bridge)})
-
-    def _get_dhcp_hosts(self, context, network_id):
-        """Get a list containing a network's hosts"""
-        hosts = []
-        for fixed_ip_ref in self.db.\
-                                 network_get_associated_fixed_ips(context,
-                                                                  network_id):
-            ethernet_card = fixed_ip_ref['ethernet_card']
-            instance = nova_db_api.\
-                       instance_get_by_virtual_nic(context,
-                                                   ethernet_card['id'])
-            if instance:
-                hosts.append(DhcpHost(mac_address=ethernet_card['mac_address'],
-                                      hostname=instance['hostname'],
-                                      ip_address=fixed_ip_ref['address'],
-                                      timestamp=None))
-        return hosts
-
-
-    def allocate_fixed_ips(self, context, vnic_ids):
-        """Gets a fixed ip from the pool."""
-        for vnic_id in vnic_ids:
-            ip_address = db_manager.bind_ip_to_ethernet_card(context, vnic_id)
-
-            if not FLAGS.fake_network:
-                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'], 
-                                             network_ref['gateway'],
-                                             network_ref['dhcp_start'],
-                                             hosts, 
-                                             dhcp_script=FLAGS.\
-                                                       ns_flat_dhcp_dhcpbridge)
-
-    def lease_fixed_ip(self, context, mac, address):
-        """Called by dhcp-bridge when ip is leased."""
-        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, 
-                                                           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)) 
-        now = datetime.datetime.utcnow()
-        self.db.fixed_ip_update(context,
-                               fixed_ip_ref['id'],
-                                {'leased': True,
-                                 'updated_at': now})
-        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."""
-        network_ref = self.db.network_get_by_bridge(context, interface)
-        hosts = []
-        for fixed_ip_ref in self.db.\
-                            network_get_associated_fixed_ips(context,
-                                                            network_ref['id']):
-            ethernet_card = fixed_ip_ref['ethernet_card']
-            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."""
-        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, 
-                                                           ethernet_card['id'])
-        if not instance:
-            raise exception.Error(_("IP %s released 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)) 
-
-        if not fixed_ip_ref['leased']:
-            LOG.warn(_("IP %s released that was not leased"), address,
-                     context=context)
-        self.db.fixed_ip_update(context,
-                                fixed_ip_ref['address'],
-                                {'leased': False})
-        if not fixed_ip_ref['allocated']:
-            self.db.fixed_ip_disassociate(context, fixed_ip_ref['id'])
-            # NOTE(vish): dhcp server isn't updated until next setup, this
-            #             means there will stale entries in the conf file
-            #             the code below will update the file if necessary
-            if FLAGS.ns_flat_dhcp_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,
-                                             dhcp_script=FLAGS.\
-                                                     ns_flat_dhcp_dhcpbridge)
-
-    def disassociate_floating_ip(self, context, floating_address):
-        """Disassociates a floating ip."""
-        fixed_address = self.db.floating_ip_disassociate(context,
-                                                         floating_address)
-        self.driver.unbind_floating_ip(floating_address)
-        self.driver.remove_floating_forward(floating_address, fixed_address)
-

=== modified file 'nova/network/flat_vlan/compute.py'
--- nova/network/flat_vlan/compute.py	2011-03-31 09:36:57 +0000
+++ nova/network/flat_vlan/compute.py	2011-04-04 00:58:27 +0000
@@ -125,8 +125,8 @@
            is_vpn: Boolean to check if the call is for VPN.
         """
         if FLAGS.net_flat_vlan_use_vlan or FLAGS.net_flat_vlan_use_dhcp:
-            driver = utils.import_object(
-                                    FLAGS.net_flat_vlan_network_agent_driver)
+            driver = utils.import_object(FLAGS.net_flat_vlan_network_driver)
+            filter_drv = utils.import_object(FLAGS.net_flat_vlan_filter_driver)
             for vnic_id in vnic_ids:
                 network_ref = db_api.network_get_by_ethernet_card(context, 
                                                                   vnic_id)
@@ -137,7 +137,8 @@
                 else:
                     driver.ensure_bridge(network_ref['bridge'],
                                  FLAGS.net_flat_vlan_dhcp_agent_interface)
-    
+                    filter_drv.ensure_bridge_forward(bridge)
+
     def teardown_compute_network(self, context, vnic_ids):
         """Clean up the compute node.
         

=== modified file 'nova/network/flat_vlan/db/api.py'
--- nova/network/flat_vlan/db/api.py	2011-03-31 06:18:29 +0000
+++ nova/network/flat_vlan/db/api.py	2011-04-04 00:58:27 +0000
@@ -24,7 +24,7 @@
 
 FLAGS = flags.FlagAccessor()
 
-IMPL = utils.LazyPluggable(FLAGS.net_flat_vlan_db_backend,
+IMPL = utils.LazyPluggable(FLAGS.get('net_flat_vlan_db_backend'),
           sqlalchemy='nova.network.flat_vlan.db.sqlalchemy.api')
 
 ###################
@@ -246,3 +246,9 @@
     """Associates an IP to an ethernet card."""
     return IMPL.dao_factory.get_dao(context).\
         fixed_ip_associate_pool(network_id, ethernet_card_id)
+
+def fixed_ip_disassociate_all_by_timeout(context, host, time):
+    """Disassociates fixed IP by timeout."""
+    return IMPL.dao_factory.get_dao(context).\
+        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-03-31 06:18:29 +0000
+++ nova/network/flat_vlan/db/sqlalchemy/api.py	2011-04-04 00:58:27 +0000
@@ -26,7 +26,6 @@
 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 api
 from nova.network.flat_vlan.db.sqlalchemy import models
 from nova.network.flat_vlan.db.sqlalchemy.session import get_session
 
@@ -74,8 +73,7 @@
     """
 
     def __init__(self):
-        self._dao_cache = api.DataAccessCache(
-            models.FlatVlanNetworkDataAccess)
+        self._dao_cache = DataAccessCache(models.FlatVlanNetworkDataAccess)
         self._session = None
 
     def get_session(self):

=== modified file 'nova/network/flat_vlan/db/sqlalchemy/models.py'
--- nova/network/flat_vlan/db/sqlalchemy/models.py	2011-03-31 06:18:29 +0000
+++ nova/network/flat_vlan/db/sqlalchemy/models.py	2011-04-04 00:58:27 +0000
@@ -19,7 +19,7 @@
 """
 from sqlalchemy import or_
 from sqlalchemy.orm import relationship, backref
-from sqlalchemy.orm import joinedload
+from sqlalchemy.orm import joinedload, joinedload_all
 from sqlalchemy import Column, Boolean, Integer, String
 from sqlalchemy import ForeignKey
 from sqlalchemy.ext.declarative import declarative_base
@@ -309,6 +309,20 @@
             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()
+        result = self._session.query(self.fixed_ip_dto_class).\
+                    filter(self.fixed_ip_dto_class.network_id.in_(inner_q)).\
+                    filter(self.fixed_ip_dto_class.updated_at < time).\
+                    filter(self.fixed_ip_dto_class.ethernet_card_id != None).\
+                    filter_by(allocated=0).\
+                    update({'ethernet_card_id': None,
+                           'leased': 0}, synchronize_session='fetch')
+        return result
 
 class FloatingIpDataAccess(DataAccess):
     """A Data Access Object to access floating IPs.

=== added directory 'nova/network/flat_vlan/driver'
=== added file 'nova/network/flat_vlan/driver/__init__.py'
--- nova/network/flat_vlan/driver/__init__.py	1970-01-01 00:00:00 +0000
+++ nova/network/flat_vlan/driver/__init__.py	2011-04-04 00:58:27 +0000
@@ -0,0 +1,16 @@
+# 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.
\ No newline at end of file

=== added directory 'nova/network/flat_vlan/driver/linux'
=== added file 'nova/network/flat_vlan/driver/linux/__init__.py'
--- nova/network/flat_vlan/driver/linux/__init__.py	1970-01-01 00:00:00 +0000
+++ nova/network/flat_vlan/driver/linux/__init__.py	2011-04-04 00:58:27 +0000
@@ -0,0 +1,16 @@
+# 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.
\ No newline at end of file

=== added file 'nova/network/flat_vlan/driver/linux/dhcp.py'
--- nova/network/flat_vlan/driver/linux/dhcp.py	1970-01-01 00:00:00 +0000
+++ nova/network/flat_vlan/driver/linux/dhcp.py	2011-04-04 00:58:27 +0000
@@ -0,0 +1,151 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 NTT.
+# 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.
+import calendar
+import os
+
+from nova import log as logging
+from nova import utils
+
+from nova.network.flat_vlan import flags
+
+LOG = logging.getLogger("nova.flat_vlan_linux_dhcp")
+FLAGS = flags.FlagAccessor()
+
+def _dhcp_file(bridge, kind):
+    """Return path to a pid, leases or conf file for a bridge"""
+    if not os.path.exists(FLAGS.net_flat_vlan_networks_path):
+        os.makedirs(FLAGS.net_flat_vlan_networks_path)
+    return os.path.abspath("%s/nova-%s.%s" % (FLAGS.net_flat_vlan_networks_path,
+                                              bridge,
+                                              kind))
+
+def _dnsmasq_cmd(bridge, gateway, dhcp_start, dhcp_script):
+    """Builds dnsmasq command"""
+    cmd = ['sudo', '-E', 'dnsmasq',
+           '--strict-order',
+           '--bind-interfaces',
+           '--conf-file=',
+           '--domain=%s' % FLAGS.net_flat_vlan_dhcp_domain,
+           '--pid-file=%s' % _dhcp_file(bridge, 'pid'),
+           '--listen-address=%s' % gateway,
+           '--except-interface=lo',
+           '--dhcp-range=%s,static,120s' % dhcp_start,
+           '--dhcp-hostsfile=%s' % _dhcp_file(bridge, 'conf'),
+           '--dhcp-script=%s' % dhcp_script, 
+           '--leasefile-ro']
+    if FLAGS.net_flat_vlan_dns_server:
+        cmd += ['-h', '-R', '--server=%s' % FLAGS.net_flat_vlan_dns_server]
+    return cmd
+
+def _dnsmasq_pid_for(bridge):
+    """Returns the pid for prior dnsmasq instance for a bridge
+
+    Returns None if no pid file exists
+
+    If machine has rebooted pid might be incorrect (caller should check)
+    """
+
+    pid_file = _dhcp_file(bridge, 'pid')
+
+    if os.path.exists(pid_file):
+        with open(pid_file, 'r') as f:
+            return int(f.read())
+
+def _stop_dnsmasq(bridge):
+    """Stops the dnsmasq instance for a given bridge"""
+    pid = _dnsmasq_pid_for(bridge)
+
+    if pid:
+        try:
+            _execute('sudo', 'kill', '-TERM', pid)
+        except Exception as exc:  # pylint: disable=W0703
+            LOG.debug(_("Killing dnsmasq threw %s"), exc)
+
+def _execute(*cmd, **kwargs):
+    """Wrapper around utils._execute for fake_network"""
+    if FLAGS.fake_network:
+        LOG.debug("FAKE NET: %s", " ".join(map(str, cmd)))
+        return "fake", 0
+    else:
+        return utils.execute(*cmd, **kwargs)
+
+def _host_dhcp(dhcp_host):
+    """Return a host string for an address"""
+    return "%s,%s.%s,%s" % (dhcp_host.mac_address,
+                            dhcp_host.hostname,
+                            FLAGS.net_flat_vlan_dhcp_domain,
+                            dhcp_host.ip_address)
+
+def _host_lease(dhcp_host):
+    """Return a host string for an address in leasefile format"""
+    seconds_since_epoch = calendar.timegm(dhcp_host.timestamp.utctimetuple())
+    lease_time = FLAGS.net_flat_vlan_dhcp_lease_time
+    return "%d %s %s %s *" % (seconds_since_epoch + lease_time,
+                              dhcp_host.mac_address,
+                              dhcp_host.address,
+                              dhcp_host.hostname or '*')
+
+def get_dhcp_hosts(dhcp_hosts):
+    """Get a string containing a network's hosts config in dnsmasq format"""
+    hosts = []
+    for dhcp_host in dhcp_hosts:
+        hosts.append(_host_dhcp(dhcp_host))
+    return '\n'.join(hosts)
+
+def get_dhcp_leases(dhcp_hosts):
+    """Return a network's hosts config in dnsmasq leasefile format"""
+    hosts = []
+    for dhcp_host in dhcp_hosts:
+        hosts.append(_host_lease(dhcp_host))
+    return '\n'.join(hosts)
+
[e-mail]('dnsmasq_start')
+def update_dhcp(bridge, gateway, dhcp_start, dhcp_hosts, 
+                dhcp_script=FLAGS.net_flat_vlan_dhcpbridge):
+    """(Re)starts a dnsmasq server for a given network
+
+    if a dnsmasq instance is already running then send a HUP
+    signal causing it to reload, otherwise spawn a new instance
+    """
+    conffile = _dhcp_file(bridge, 'conf')
+    with open(conffile, 'w') as f:
+        f.write(get_dhcp_hosts(dhcp_hosts))
+
+    # Make sure dnsmasq can actually read it (it setuid()s to "nobody")
+    os.chmod(conffile, 0644)
+
+    pid = _dnsmasq_pid_for(bridge)
+
+    # if dnsmasq is already running, then tell it to reload
+    if pid:
+        out, _err = _execute('cat', "/proc/%d/cmdline" % pid,
+                             check_exit_code=False)
+        if conffile in out:
+            try:
+                _execute('sudo', 'kill', '-HUP', pid)
+                return
+            except Exception as exc:  # pylint: disable-msg=W0703
+                LOG.debug(_("Hupping dnsmasq threw %s"), exc)
+        else:
+            LOG.debug(_("Pid %d is stale, relaunching dnsmasq"), pid)
+
+    # FLAGFILE and DNSMASQ_INTERFACE in env
+    env = {'FLAGFILE': FLAGS.net_flat_vlan_dhcpbridge_flagfile,
+           'DNSMASQ_INTERFACE': bridge}
+    command = _dnsmasq_cmd(bridge, gateway, dhcp_start, dhcp_script)
+    _execute(*command, addl_env=env)
+

=== added file 'nova/network/flat_vlan/driver/linux/filter.py'
--- nova/network/flat_vlan/driver/linux/filter.py	1970-01-01 00:00:00 +0000
+++ nova/network/flat_vlan/driver/linux/filter.py	2011-04-04 00:58:27 +0000
@@ -0,0 +1,391 @@
+# 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.
+import inspect
+import os
+
+from nova import log as logging
+from nova import utils
+
+from nova.network.flat_vlan import flags
+
+LOG = logging.getLogger("nova.flat_vlan_linux_filter")
+FLAGS = flags.FlagAccessor()
+
+binary_name = os.path.basename(inspect.stack()[-1][1])
+
+def _execute(*cmd, **kwargs):
+    """Wrapper around utils._execute for fake_network"""
+    if FLAGS.fake_network:
+        LOG.debug("FAKE NET: %s", " ".join(map(str, cmd)))
+        return "fake", 0
+    else:
+        return utils.execute(*cmd, **kwargs)
+
+class IptablesRule(object):
+    """An iptables rule
+
+    You shouldn't need to use this class directly, it's only used by
+    IptablesManager
+    """
+    def __init__(self, chain, rule, wrap=True, top=False):
+        self.chain = chain
+        self.rule = rule
+        self.wrap = wrap
+        self.top = top
+
+    def __eq__(self, other):
+        return ((self.chain == other.chain) and
+                (self.rule == other.rule) and
+                (self.top == other.top) and
+                (self.wrap == other.wrap))
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __str__(self):
+        if self.wrap:
+            chain = '%s-%s' % (binary_name, self.chain)
+        else:
+            chain = self.chain
+        return '-A %s %s' % (chain, self.rule)
+
+
+class IptablesTable(object):
+    """An iptables table"""
+
+    def __init__(self):
+        self.rules = []
+        self.chains = set()
+        self.unwrapped_chains = set()
+
+    def add_chain(self, name, wrap=True):
+        """Adds a named chain to the table
+
+        The chain name is wrapped to be unique for the component creating
+        it, so different components of Nova can safely create identically
+        named chains without interfering with one another.
+
+        At the moment, its wrapped name is <binary name>-<chain name>,
+        so if nova-compute creates a chain named "OUTPUT", it'll actually
+        end up named "nova-compute-OUTPUT".
+        """
+        if wrap:
+            self.chains.add(name)
+        else:
+            self.unwrapped_chains.add(name)
+
+    def remove_chain(self, name, wrap=True):
+        """Remove named chain
+
+        This removal "cascades". All rule in the chain are removed, as are
+        all rules in other chains that jump to it.
+
+        If the chain is not found, this is merely logged.
+        """
+        if wrap:
+            chain_set = self.chains
+        else:
+            chain_set = self.unwrapped_chains
+
+        if name not in chain_set:
+            LOG.debug(_("Attempted to remove chain %s which doesn't exist"),
+                      name)
+            return
+
+        chain_set.remove(name)
+        self.rules = filter(lambda r: r.chain != name, self.rules)
+
+        if wrap:
+            jump_snippet = '-j %s-%s' % (binary_name, name)
+        else:
+            jump_snippet = '-j %s' % (name,)
+
+        self.rules = filter(lambda r: jump_snippet not in r.rule, self.rules)
+
+    def add_rule(self, chain, rule, wrap=True, top=False):
+        """Add a rule to the table
+
+        This is just like what you'd feed to iptables, just without
+        the "-A <chain name>" bit at the start.
+
+        However, if you need to jump to one of your wrapped chains,
+        prepend its name with a '$' which will ensure the wrapping
+        is applied correctly.
+        """
+        if wrap and chain not in self.chains:
+            raise ValueError(_("Unknown chain: %r") % chain)
+
+        if '$' in rule:
+            rule = ' '.join(map(self._wrap_target_chain, rule.split(' ')))
+
+        self.rules.append(IptablesRule(chain, rule, wrap, top))
+
+    def _wrap_target_chain(self, s):
+        if s.startswith('$'):
+            return '%s-%s' % (binary_name, s[1:])
+        return s
+
+    def remove_rule(self, chain, rule, wrap=True, top=False):
+        """Remove a rule from a chain
+
+        Note: The rule must be exactly identical to the one that was added.
+        You cannot switch arguments around like you can with the iptables
+        CLI tool.
+        """
+        try:
+            self.rules.remove(IptablesRule(chain, rule, wrap, top))
+        except ValueError:
+            LOG.debug(_("Tried to remove rule that wasn't there:"
+                        " %(chain)r %(rule)r %(wrap)r %(top)r"),
+                      {'chain': chain, 'rule': rule,
+                       'top': top, 'wrap': wrap})
+
+
+class IptablesManager(object):
+    """Wrapper for iptables
+
+    See IptablesTable for some usage docs
+
+    A number of chains are set up to begin with.
+
+    First, nova-filter-top. It's added at the top of FORWARD and OUTPUT. Its
+    name is not wrapped, so it's shared between the various nova workers. It's
+    intended for rules that need to live at the top of the FORWARD and OUTPUT
+    chains. It's in both the ipv4 and ipv6 set of tables.
+
+    For ipv4 and ipv6, the builtin INPUT, OUTPUT, and FORWARD filter chains are
+    wrapped, meaning that the "real" INPUT chain has a rule that jumps to the
+    wrapped INPUT chain, etc. Additionally, there's a wrapped chain named
+    "local" which is jumped to from nova-filter-top.
+
+    For ipv4, the builtin PREROUTING, OUTPUT, and POSTROUTING nat chains are
+    wrapped in the same was as the builtin filter chains. Additionally, there's
+    a snat chain that is applied after the POSTROUTING chain.
+    """
+    def __init__(self, execute=None):
+        if not execute:
+            self.execute = _execute
+        else:
+            self.execute = execute
+
+        self.ipv4 = {'filter': IptablesTable(),
+                     'nat': IptablesTable()}
+        self.ipv6 = {'filter': IptablesTable()}
+
+        # Add a nova-filter-top chain. It's intended to be shared
+        # among the various nova components. It sits at the very top
+        # of FORWARD and OUTPUT.
+        for tables in [self.ipv4, self.ipv6]:
+            tables['filter'].add_chain('nova-filter-top', wrap=False)
+            tables['filter'].add_rule('FORWARD', '-j nova-filter-top',
+                                      wrap=False, top=True)
+            tables['filter'].add_rule('OUTPUT', '-j nova-filter-top',
+                                      wrap=False, top=True)
+
+            tables['filter'].add_chain('local')
+            tables['filter'].add_rule('nova-filter-top', '-j $local',
+                                      wrap=False)
+
+        # Wrap the builtin chains
+        builtin_chains = {4: {'filter': ['INPUT', 'OUTPUT', 'FORWARD'],
+                              'nat': ['PREROUTING', 'OUTPUT', 'POSTROUTING']},
+                          6: {'filter': ['INPUT', 'OUTPUT', 'FORWARD']}}
+
+        for ip_version in builtin_chains:
+            if ip_version == 4:
+                tables = self.ipv4
+            elif ip_version == 6:
+                tables = self.ipv6
+
+            for table, chains in builtin_chains[ip_version].iteritems():
+                for chain in chains:
+                    tables[table].add_chain(chain)
+                    tables[table].add_rule(chain, '-j $%s' % (chain,),
+                                           wrap=False)
+
+        # Add a nova-postrouting-bottom chain. It's intended to be shared
+        # among the various nova components. We set it as the last chain
+        # of POSTROUTING chain.
+        self.ipv4['nat'].add_chain('nova-postrouting-bottom', wrap=False)
+        self.ipv4['nat'].add_rule('POSTROUTING', '-j nova-postrouting-bottom',
+                                  wrap=False)
+
+        # We add a snat chain to the shared nova-postrouting-bottom chain
+        # so that it's applied last.
+        self.ipv4['nat'].add_chain('snat')
+        self.ipv4['nat'].add_rule('nova-postrouting-bottom', '-j $snat',
+                                  wrap=False)
+
+        # And then we add a floating-snat chain and jump to first thing in
+        # the snat chain.
+        self.ipv4['nat'].add_chain('floating-snat')
+        self.ipv4['nat'].add_rule('snat', '-j $floating-snat')
+
+    @utils.synchronized('iptables', external=True)
+    def apply(self):
+        """Apply the current in-memory set of iptables rules
+
+        This will blow away any rules left over from previous runs of the
+        same component of Nova, and replace them with our current set of
+        rules. This happens atomically, thanks to iptables-restore.
+        """
+        s = [('iptables', self.ipv4)]
+        if FLAGS.net_flat_vlan_use_ipv6:
+            s += [('ip6tables', self.ipv6)]
+
+        for cmd, tables in s:
+            for table in tables:
+                current_table, _ = self.execute('sudo',
+                                                '%s-save' % (cmd,),
+                                                '-t', '%s' % (table,),
+                                                attempts=5)
+                current_lines = current_table.split('\n')
+                new_filter = self._modify_rules(current_lines,
+                                                tables[table])
+                self.execute('sudo', '%s-restore' % (cmd,),
+                             process_input='\n'.join(new_filter),
+                             attempts=5)
+
+    def _modify_rules(self, current_lines, table, binary=None):
+        unwrapped_chains = table.unwrapped_chains
+        chains = table.chains
+        rules = table.rules
+
+        # Remove any trace of our rules
+        new_filter = filter(lambda line: binary_name not in line,
+                            current_lines)
+
+        seen_chains = False
+        rules_index = 0
+        for rules_index, rule in enumerate(new_filter):
+            if not seen_chains:
+                if rule.startswith(':'):
+                    seen_chains = True
+            else:
+                if not rule.startswith(':'):
+                    break
+
+        our_rules = []
+        for rule in rules:
+            rule_str = str(rule)
+            if rule.top:
+                # rule.top == True means we want this rule to be at the top.
+                # Further down, we weed out duplicates from the bottom of the
+                # list, so here we remove the dupes ahead of time.
+                new_filter = filter(lambda s: s.strip() != rule_str.strip(),
+                                    new_filter)
+            our_rules += [rule_str]
+
+        new_filter[rules_index:rules_index] = our_rules
+
+        new_filter[rules_index:rules_index] = [':%s - [0:0]' % \
+                                               (name,) \
+                                               for name in unwrapped_chains]
+        new_filter[rules_index:rules_index] = [':%s-%s - [0:0]' % \
+                                               (binary_name, name,) \
+                                               for name in chains]
+
+        seen_lines = set()
+
+        def _weed_out_duplicates(line):
+            line = line.strip()
+            if line in seen_lines:
+                return False
+            else:
+                seen_lines.add(line)
+                return True
+
+        # We filter duplicates, letting the *last* occurrence take
+        # precendence.
+        new_filter.reverse()
+        new_filter = filter(_weed_out_duplicates, new_filter)
+        new_filter.reverse()
+        return new_filter
+
+
+def metadata_forward():
+    """Create forwarding rule for metadata"""
+    iptables_manager.ipv4['nat'].add_rule("PREROUTING",
+                                          "-s 0.0.0.0/0 -d 169.254.169.254/32 "
+                                          "-p tcp -m tcp --dport 80 -j DNAT "
+                                          "--to-destination %s:%s" % \
+                                          (FLAGS.ec2_dmz_host, 
+                                           FLAGS.ec2_port))
+    iptables_manager.apply()
+
+def init_host():
+    """Basic networking setup goes here"""
+    # NOTE(devcamcar): Cloud public SNAT entries and the default
+    # SNAT rule for outbound traffic.
+    iptables_manager.ipv4['nat'].add_rule("snat",
+                                          "-s %s -j SNAT --to-source %s" % \
+                                        (FLAGS.net_flat_vlan_fixed_range,
+                                        FLAGS.net_flat_vlan_routing_source_ip))
+
+    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
+                                          "-s %s -d %s -j ACCEPT" % \
+                                          (FLAGS.net_flat_vlan_fixed_range, 
+                                           FLAGS.net_flat_vlan_dmz_cidr))
+
+    iptables_manager.ipv4['nat'].add_rule("POSTROUTING",
+                                          "-s %(range)s -d %(range)s "
+                                          "-j ACCEPT" % \
+                                    {'range': FLAGS.net_flat_vlan_fixed_range})
+    iptables_manager.apply()
+
+def ensure_vlan_forward(public_ip, port, private_ip):
+    """Sets up forwarding rules for vlan"""
+    iptables_manager.ipv4['filter'].add_rule("FORWARD",
+                                             "-d %s -p udp "
+                                             "--dport 1194 "
+                                             "-j ACCEPT" % private_ip)
+    iptables_manager.ipv4['nat'].add_rule("PREROUTING",
+                                          "-d %s -p udp "
+                                          "--dport %s -j DNAT --to %s:1194" %
+                                          (public_ip, port, private_ip))
+    iptables_manager.apply()
+
+
+def ensure_floating_forward(floating_ip, fixed_ip):
+    """Ensure floating ip forwarding rule"""
+    for chain, rule in floating_forward_rules(floating_ip, fixed_ip):
+        iptables_manager.ipv4['nat'].add_rule(chain, rule)
+    iptables_manager.apply()
+
+
+def remove_floating_forward(floating_ip, fixed_ip):
+    """Remove forwarding for floating ip"""
+    for chain, rule in floating_forward_rules(floating_ip, fixed_ip):
+        iptables_manager.ipv4['nat'].remove_rule(chain, rule)
+    iptables_manager.apply()
+
+
+def floating_forward_rules(floating_ip, fixed_ip):
+    return [("PREROUTING", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
+            ("OUTPUT", "-d %s -j DNAT --to %s" % (floating_ip, fixed_ip)),
+            ("floating-snat",
+             "-s %s -j SNAT --to %s" % (fixed_ip, floating_ip))]
+
+def ensure_bridge_forward(bridge):
+    iptables_manager.ipv4['filter'].add_rule("FORWARD",
+                                             "--in-interface %s -j ACCEPT" % \
+                                             bridge)
+    iptables_manager.ipv4['filter'].add_rule("FORWARD",
+                                             "--out-interface %s -j ACCEPT" % \
+                                             bridge)    
+
+iptables_manager = IptablesManager()
\ No newline at end of file

=== added file 'nova/network/flat_vlan/driver/linux/network.py'
--- nova/network/flat_vlan/driver/linux/network.py	1970-01-01 00:00:00 +0000
+++ nova/network/flat_vlan/driver/linux/network.py	2011-04-04 00:58:27 +0000
@@ -0,0 +1,149 @@
+# 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.
+"""
+Implements vlans, bridges, and iptables rules using linux utilities.
+"""
+import os
+
+from nova import exception
+from nova import log as logging
+from nova import utils
+
+from nova.network.flat_vlan import flags
+
+LOG = logging.getLogger("nova.flat_vlan_linux_net")
+FLAGS = flags.FlagAccessor()
+
+def bind_floating_ip(floating_ip, check_exit_code=True):
+    """Bind ip to public interface"""
+    _execute('sudo', 'ip', 'addr', 'add', floating_ip,
+             'dev', FLAGS.net_flat_vlan_public_interface,
+             check_exit_code=check_exit_code)
+
+def unbind_floating_ip(floating_ip):
+    """Unbind a public ip from public interface"""
+    _execute('sudo', 'ip', 'addr', 'del', floating_ip,
+             'dev', FLAGS.net_flat_vlan_public_interface)
+
+def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
+    """Create a vlan and bridge unless they already exist"""
+    interface = ensure_vlan(vlan_num)
+    ensure_bridge(bridge, interface, net_attrs)
+
+def ensure_vlan(vlan_num):
+    """Create a vlan unless it already exists"""
+    interface = "vlan%s" % vlan_num
+    if not _device_exists(interface):
+        LOG.debug(_("Starting VLAN inteface %s"), interface)
+        _execute('sudo', 'vconfig', 'set_name_type', 'VLAN_PLUS_VID_NO_PAD')
+        _execute('sudo', 'vconfig', 'add', FLAGS.net_flat_vlan_vlan_interface, 
+                 vlan_num)
+        _execute('sudo', 'ip', 'link', 'set', interface, 'up')
+    return interface
+
+def ensure_bridge(bridge, interface, net_attrs=None):
+    """Create a bridge unless it already exists.
+
+    :param interface: the interface to create the bridge on.
+    :param net_attrs: dictionary with  attributes used to create the bridge.
+
+    If net_attrs is set, it will add the net_attrs['gateway'] to the bridge
+    using net_attrs['broadcast'] and net_attrs['cidr'].  It will also add
+    the ip_v6 address specified in net_attrs['cidr_v6'] if 
+    net_flat_vlan_use_ipv6 is set.
+
+    The code will attempt to move any ips that already exist on the interface
+    onto the bridge and reset the default gateway if necessary.
+    """
+    if not _device_exists(bridge):
+        LOG.debug(_("Starting Bridge interface for %s"), interface)
+        _execute('sudo', 'brctl', 'addbr', bridge)
+        _execute('sudo', 'brctl', 'setfd', bridge, 0)
+        # _execute("sudo brctl setageing %s 10" % bridge)
+        _execute('sudo', 'brctl', 'stp', bridge, 'off')
+        _execute('sudo', 'ip', 'link', 'set', bridge, 'up')
+    if net_attrs:
+        # NOTE(vish): The ip for dnsmasq has to be the first address on the
+        #             bridge for it to respond to reqests properly
+        suffix = net_attrs['cidr'].rpartition('/')[2]
+        out, err = _execute('sudo', 'ip', 'addr', 'add',
+                            "%s/%s" %
+                            (net_attrs['gateway'], suffix),
+                            'brd',
+                            net_attrs['broadcast'],
+                            'dev',
+                            bridge,
+                            check_exit_code=False)
+        if err and err != "RTNETLINK answers: File exists\n":
+            raise exception.Error("Failed to add ip: %s" % err)
+        if(FLAGS.net_flat_vlan_use_ipv6):
+            _execute('sudo', 'ip', '-f', 'inet6', 'addr',
+                     'change', net_attrs['cidr_v6'],
+                     'dev', bridge)
+        # NOTE(vish): If the public interface is the same as the
+        #             bridge, then the bridge has to be in promiscuous
+        #             to forward packets properly.
+        if(FLAGS.net_flat_vlan_public_interface == bridge):
+            _execute('sudo', 'ip', 'link', 'set',
+                     'dev', bridge, 'promisc', 'on')
+    if interface:
+        # NOTE(vish): This will break if there is already an ip on the
+        #             interface, so we move any ips to the bridge
+        gateway = None
+        out, err = _execute('sudo', 'route', '-n')
+        for line in out.split("\n"):
+            fields = line.split()
+            if fields and fields[0] == "0.0.0.0" and fields[-1] == interface:
+                gateway = fields[1]
+        out, err = _execute('sudo', 'ip', 'addr', 'show', 'dev', interface,
+                            'scope', 'global')
+        for line in out.split("\n"):
+            fields = line.split()
+            if fields and fields[0] == "inet":
+                params = fields[1:-1]
+                _execute(*_ip_bridge_cmd('del', params, fields[-1]))
+                _execute(*_ip_bridge_cmd('add', params, bridge))
+        if gateway:
+            _execute('sudo', 'route', 'add', '0.0.0.0', 'gw', gateway)
+        out, err = _execute('sudo', 'brctl', 'addif', bridge, interface,
+                            check_exit_code=False)
+
+        if (err and err != "device %s is already a member of a bridge; can't "
+                           "enslave it to bridge %s.\n" % (interface, bridge)):
+            raise exception.Error("Failed to add interface: %s" % err)
+
+def _execute(*cmd, **kwargs):
+    """Wrapper around utils._execute for fake_network"""
+    if FLAGS.fake_network:
+        LOG.debug("FAKE NET: %s", " ".join(map(str, cmd)))
+        return "fake", 0
+    else:
+        return utils.execute(*cmd, **kwargs)
+
+def _device_exists(device):
+    """Check if ethernet device exists"""
+    (_out, err) = _execute('ip', 'link', 'show', 'dev', device,
+                           check_exit_code=False)
+    return not err
+
+def _ip_bridge_cmd(action, params, device):
+    """Build commands to add/del ips to bridges/devices"""
+
+    cmd = ['sudo', 'ip', 'addr', action]
+    cmd.extend(params)
+    cmd.extend(['dev', device])
+    return cmd

=== added file 'nova/network/flat_vlan/driver/linux/ra.py'
--- nova/network/flat_vlan/driver/linux/ra.py	1970-01-01 00:00:00 +0000
+++ nova/network/flat_vlan/driver/linux/ra.py	2011-04-04 00:58:27 +0000
@@ -0,0 +1,107 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 NTT.
+# 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.
+
+import os
+
+from nova import log as logging
+from nova import utils
+
+from nova.network.flat_vlan import flags
+
+LOG = logging.getLogger("nova.flat_vlan_linux_ra")
+
+FLAGS = flags.FlagAccessor()
+
+def _ra_file(bridge, kind):
+    """Return path to a pid or conf file for a bridge"""
+
+    if not os.path.exists(FLAGS.net_flat_vlan_networks_path):
+        os.makedirs(FLAGS.net_flat_vlan_networks_path)
+    return os.path.abspath("%s/nova-ra-%s.%s" % (
+                                            FLAGS.net_flat_vlan_networks_path,
+                                            bridge,
+                                            kind))
+
+def _ra_pid_for(bridge):
+    """Returns the pid for prior radvd instance for a bridge
+
+    Returns None if no pid file exists
+
+    If machine has rebooted pid might be incorrect (caller should check)
+    """
+
+    pid_file = _ra_file(bridge, 'pid')
+
+    if os.path.exists(pid_file):
+        with open(pid_file, 'r') as f:
+            return int(f.read())
+
+def _execute(*cmd, **kwargs):
+    """Wrapper around utils._execute for fake_network"""
+    if FLAGS.fake_network:
+        LOG.debug("FAKE NET: %s", " ".join(map(str, cmd)))
+        return "fake", 0
+    else:
+        return utils.execute(*cmd, **kwargs)