Upstream merge

94 files changed, 3712 insertions, 1547 deletions

diff --git a/Authors b/Authors
index c8193e3f4..d4d905139 100644
--- a/Authors
+++ b/Authors
@@ -102,6 +102,7 @@ Thierry Carrez <thierry@openstack.org>
 Tim Simpson <tim.simpson@rackspace.com>
 Todd Willey <todd@ansolabs.com>
 Trey Morris <trey.morris@rackspace.com>
+Troy Toman <troy.toman@rackspace.com>
 Tushar Patil <tushar.vitthal.patil@gmail.com>
 Vasiliy Shlykov <vash@vasiliyshlykov.org>
 Vishvananda Ishaya <vishvananda@gmail.com>
diff --git a/bin/nova-ajax-console-proxy b/bin/nova-ajax-console-proxy
index 2329581a2..0a789b4b9 100755
--- a/bin/nova-ajax-console-proxy
+++ b/bin/nova-ajax-console-proxy
@@ -24,7 +24,6 @@ from eventlet import greenthread
 from eventlet.green import urllib2
 
 import exceptions
-import gettext
 import os
 import sys
 import time
@@ -38,11 +37,11 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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 rpc
+from nova import service
 from nova import utils
 from nova import wsgi
 
@@ -141,5 +140,5 @@ if __name__ == '__main__':
     acp = AjaxConsoleProxy()
     acp.register_listeners()
     server = wsgi.Server("AJAX Console Proxy", acp, port=acp_port)
-    server.start()
-    server.wait()
+    service.serve(server)
+    service.wait()
diff --git a/bin/nova-api b/bin/nova-api
index fe8e83366..38e2624d8 100755
--- a/bin/nova-api
+++ b/bin/nova-api
@@ -19,12 +19,14 @@
 
 """Starter script for Nova API.
 
-Starts both the EC2 and OpenStack APIs in separate processes.
+Starts both the EC2 and OpenStack APIs in separate greenthreads.
 
 """
 
+import eventlet
+eventlet.monkey_patch()
+
 import os
-import signal
 import sys
 
 
@@ -33,32 +35,18 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(
 if os.path.exists(os.path.join(possible_topdir, "nova", "__init__.py")):
     sys.path.insert(0, possible_topdir)
 
-import nova.service
-import nova.utils
 
 from nova import flags
-
-
-FLAGS = flags.FLAGS
-
-
-def main():
-    """Launch EC2 and OSAPI services."""
-    nova.utils.Bootstrapper.bootstrap_binary(sys.argv)
-
-    launcher = nova.service.Launcher()
-
-    for api in FLAGS.enabled_apis:
-        service = nova.service.WSGIService(api)
-        launcher.launch_service(service)
-
-    signal.signal(signal.SIGTERM, lambda *_: launcher.stop())
-
-    try:
-        launcher.wait()
-    except KeyboardInterrupt:
-        launcher.stop()
-
+from nova import log as logging
+from nova import service
+from nova import utils
 
 if __name__ == '__main__':
-    sys.exit(main())
+    utils.default_flagfile()
+    flags.FLAGS(sys.argv)
+    logging.setup()
+    servers = []
+    for api in flags.FLAGS.enabled_apis:
+        servers.append(service.WSGIService(api))
+    service.serve(*servers)
+    service.wait()
diff --git a/bin/nova-api-ec2 b/bin/nova-api-ec2
new file mode 100755
index 000000000..df50f713d
--- /dev/null
+++ b/bin/nova-api-ec2
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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 EC2 API."""
+
+import eventlet
+eventlet.monkey_patch()
+
+import os
+import sys
+
+
+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)
+
+
+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()
+    server = service.WSGIService('ec2')
+    service.serve(server)
+    service.wait()
diff --git a/bin/nova-api-os b/bin/nova-api-os
new file mode 100755
index 000000000..374e850ea
--- /dev/null
+++ b/bin/nova-api-os
@@ -0,0 +1,46 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 United States Government as represented by the
+# Administrator of the National Aeronautics and Space Administration.
+# 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 OS API."""
+
+import eventlet
+eventlet.monkey_patch()
+
+import os
+import sys
+
+
+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)
+
+
+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()
+    server = service.WSGIService('osapi')
+    service.serve(server)
+    service.wait()
diff --git a/bin/nova-compute b/bin/nova-compute
index cd7c78def..5239fae72 100755
--- a/bin/nova-compute
+++ b/bin/nova-compute
@@ -22,7 +22,6 @@
 import eventlet
 eventlet.monkey_patch()
 
-import gettext
 import os
 import sys
 
@@ -34,7 +33,6 @@ POSSIBLE_TOPDIR = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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
@@ -45,5 +43,6 @@ if __name__ == '__main__':
     utils.default_flagfile()
     flags.FLAGS(sys.argv)
     logging.setup()
-    service.serve()
+    server = service.Service.create(binary='nova-compute')
+    service.serve(server)
     service.wait()
diff --git a/bin/nova-console b/bin/nova-console
index 40608b995..22f6ef171 100755
--- a/bin/nova-console
+++ b/bin/nova-console
@@ -21,7 +21,6 @@
 import eventlet
 eventlet.monkey_patch()
 
-import gettext
 import os
 import sys
 
@@ -33,7 +32,6 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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
@@ -44,5 +42,6 @@ if __name__ == '__main__':
     utils.default_flagfile()
     flags.FLAGS(sys.argv)
     logging.setup()
-    service.serve()
+    server = service.Service.create(binary='nova-console')
+    service.serve(server)
     service.wait()
diff --git a/bin/nova-dhcpbridge b/bin/nova-dhcpbridge
index 621222d8f..1c9ae951e 100755
--- a/bin/nova-dhcpbridge
+++ b/bin/nova-dhcpbridge
@@ -48,12 +48,11 @@ flags.DECLARE('auth_driver', 'nova.auth.manager')
 flags.DECLARE('network_size', 'nova.network.manager')
 flags.DECLARE('num_networks', 'nova.network.manager')
 flags.DECLARE('update_dhcp_on_disassociate', 'nova.network.manager')
-flags.DEFINE_string('dnsmasq_interface', 'br0', 'Default Dnsmasq interface')
 
 LOG = logging.getLogger('nova.dhcpbridge')
 
 
-def add_lease(mac, ip_address, _interface):
+def add_lease(mac, ip_address):
     """Set the IP that was assigned by the DHCP server."""
     if FLAGS.fake_rabbit:
         LOG.debug(_("leasing ip"))
@@ -67,13 +66,13 @@ def add_lease(mac, ip_address, _interface):
                   "args": {"address": ip_address}})
 
 
-def old_lease(mac, ip_address, interface):
+def old_lease(mac, ip_address):
     """Update just as add lease."""
     LOG.debug(_("Adopted old lease or got a change of mac"))
-    add_lease(mac, ip_address, interface)
+    add_lease(mac, ip_address)
 
 
-def del_lease(mac, ip_address, _interface):
+def del_lease(mac, ip_address):
     """Called when a lease expires."""
     if FLAGS.fake_rabbit:
         LOG.debug(_("releasing ip"))
@@ -87,10 +86,10 @@ def del_lease(mac, ip_address, _interface):
                   "args": {"address": ip_address}})
 
 
-def init_leases(interface):
-    """Get the list of hosts for an interface."""
+def init_leases(network_id):
+    """Get the list of hosts for a network."""
     ctxt = context.get_admin_context()
-    network_ref = db.network_get_by_bridge(ctxt, interface)
+    network_ref = db.network_get(ctxt, network_id)
     return linux_net.get_dhcp_leases(ctxt, network_ref)
 
 
@@ -100,8 +99,7 @@ def main():
     utils.default_flagfile(flagfile)
     argv = FLAGS(sys.argv)
     logging.setup()
-    # check ENV first so we don't break any older deploys
-    interface = os.environ.get('DNSMASQ_INTERFACE', FLAGS.dnsmasq_interface)
+
     if int(os.environ.get('TESTING', '0')):
         from nova.tests import fake_flags
 
@@ -115,12 +113,20 @@ def main():
     if action in ['add', 'del', 'old']:
         mac = argv[2]
         ip = argv[3]
-        msg = _("Called %(action)s for mac %(mac)s with ip %(ip)s"
-                " on interface %(interface)s") % locals()
+        msg = _("Called '%(action)s' for mac '%(mac)s' with ip '%(ip)s'") % \
+                    {"action": action,
+                     "mac": mac,
+                     "ip": ip}
         LOG.debug(msg)
-        globals()[action + '_lease'](mac, ip, interface)
+        globals()[action + '_lease'](mac, ip)
     else:
-        print init_leases(interface)
+        try:
+            network_id = int(os.environ.get('NETWORK_ID'))
+        except TypeError:
+            LOG.error(_("Environment variable 'NETWORK_ID' must be set."))
+            sys.exit(1)
+
+        print init_leases(network_id)
 
 if __name__ == "__main__":
     main()
diff --git a/bin/nova-direct-api b/bin/nova-direct-api
index c6cf9b2ff..106e89ba9 100755
--- a/bin/nova-direct-api
+++ b/bin/nova-direct-api
@@ -20,7 +20,9 @@
 
 """Starter script for Nova Direct API."""
 
-import gettext
+import eventlet
+eventlet.monkey_patch()
+
 import os
 import sys
 
@@ -32,12 +34,12 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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 compute
 from nova import flags
 from nova import log as logging
 from nova import network
+from nova import service
 from nova import utils
 from nova import volume
 from nova import wsgi
@@ -97,5 +99,6 @@ if __name__ == '__main__':
                          with_auth,
                          host=FLAGS.direct_host,
                          port=FLAGS.direct_port)
-    server.start()
-    server.wait()
+
+    service.serve(server)
+    service.wait()
diff --git a/bin/nova-manage b/bin/nova-manage
index 3959a236e..8e6419c0b 100755
--- a/bin/nova-manage
+++ b/bin/nova-manage
@@ -719,7 +719,7 @@ class NetworkCommands(object):
         # sanitize other input using FLAGS if necessary
         if not num_networks:
             num_networks = FLAGS.num_networks
-        if not network_size:
+        if not network_size and fixed_range_v4:
             fixnet = netaddr.IPNetwork(fixed_range_v4)
             each_subnet_size = fixnet.size / int(num_networks)
             if each_subnet_size > FLAGS.network_size:
@@ -741,6 +741,9 @@ class NetworkCommands(object):
         if not dns1 and FLAGS.flat_network_dns:
             dns1 = FLAGS.flat_network_dns
 
+        if not network_size:
+            network_size = FLAGS.network_size
+
         # create the network
         net_manager = utils.import_object(FLAGS.network_manager)
         net_manager.create_networks(context.get_admin_context(),
diff --git a/bin/nova-network b/bin/nova-network
index 101761ef7..57759d30a 100755
--- a/bin/nova-network
+++ b/bin/nova-network
@@ -22,7 +22,6 @@
 import eventlet
 eventlet.monkey_patch()
 
-import gettext
 import os
 import sys
 
@@ -34,7 +33,6 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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
@@ -45,5 +43,6 @@ if __name__ == '__main__':
     utils.default_flagfile()
     flags.FLAGS(sys.argv)
     logging.setup()
-    service.serve()
+    server = service.Service.create(binary='nova-network')
+    service.serve(server)
     service.wait()
diff --git a/bin/nova-objectstore b/bin/nova-objectstore
index 4d5aec445..c7a76e120 100755
--- a/bin/nova-objectstore
+++ b/bin/nova-objectstore
@@ -17,11 +17,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-"""
-  Daemon for nova objectstore. Supports S3 API.
-"""
+"""Daemon for nova objectstore. Supports S3 API."""
+
+import eventlet
+eventlet.monkey_patch()
 
-import gettext
 import os
 import sys
 
@@ -33,10 +33,10 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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
 from nova import wsgi
 from nova.objectstore import s3server
@@ -54,5 +54,5 @@ if __name__ == '__main__':
                          router,
                          port=FLAGS.s3_port,
                          host=FLAGS.s3_host)
-    server.start()
-    server.wait()
+    service.serve(server)
+    service.wait()
diff --git a/bin/nova-scheduler b/bin/nova-scheduler
index 0c205a80f..2e168cbc6 100755
--- a/bin/nova-scheduler
+++ b/bin/nova-scheduler
@@ -22,7 +22,6 @@
 import eventlet
 eventlet.monkey_patch()
 
-import gettext
 import os
 import sys
 
@@ -34,7 +33,6 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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
@@ -45,5 +43,6 @@ if __name__ == '__main__':
     utils.default_flagfile()
     flags.FLAGS(sys.argv)
     logging.setup()
-    service.serve()
+    server = service.Service.create(binary='nova-scheduler')
+    service.serve(server)
     service.wait()
diff --git a/bin/nova-vncproxy b/bin/nova-vncproxy
index bdbb30a7f..dc08e2433 100755
--- a/bin/nova-vncproxy
+++ b/bin/nova-vncproxy
@@ -19,7 +19,8 @@
 """VNC Console Proxy Server."""
 
 import eventlet
-import gettext
+eventlet.monkey_patch()
+
 import os
 import sys
 
@@ -29,7 +30,6 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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
@@ -41,7 +41,7 @@ from nova.vnc import auth
 from nova.vnc import proxy
 
 
-LOG = logging.getLogger('nova.vnc-proxy')
+LOG = logging.getLogger('nova.vncproxy')
 
 
 FLAGS = flags.FLAGS
@@ -81,7 +81,7 @@ if __name__ == "__main__":
     FLAGS(sys.argv)
     logging.setup()
 
-    LOG.audit(_("Starting nova-vnc-proxy node (version %s)"),
+    LOG.audit(_("Starting nova-vncproxy node (version %s)"),
               version.version_string_with_vcs())
 
     if not (os.path.exists(FLAGS.vncproxy_wwwroot) and
@@ -107,13 +107,10 @@ if __name__ == "__main__":
     else:
         with_auth = auth.VNCNovaAuthMiddleware(with_logging)
 
-    service.serve()
-
     server = wsgi.Server("VNC Proxy",
                          with_auth,
                          host=FLAGS.vncproxy_host,
                          port=FLAGS.vncproxy_port)
-    server.start()
     server.start_tcp(handle_flash_socket_policy, 843, host=FLAGS.vncproxy_host)
-
-    server.wait()
+    service.serve(server)
+    service.wait()
diff --git a/bin/nova-volume b/bin/nova-volume
index 8dcdbc500..5405aebbb 100755
--- a/bin/nova-volume
+++ b/bin/nova-volume
@@ -22,7 +22,6 @@
 import eventlet
 eventlet.monkey_patch()
 
-import gettext
 import os
 import sys
 
@@ -34,7 +33,6 @@ possible_topdir = os.path.normpath(os.path.join(os.path.abspath(sys.argv[0]),
 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
@@ -45,5 +43,6 @@ if __name__ == '__main__':
     utils.default_flagfile()
     flags.FLAGS(sys.argv)
     logging.setup()
-    service.serve()
+    server = service.Service.create(binary='nova-volume')
+    service.serve(server)
     service.wait()
diff --git a/doc/source/devref/distributed_scheduler.rst b/doc/source/devref/distributed_scheduler.rst
index e33fda4d2..c63e62f7f 100644
--- a/doc/source/devref/distributed_scheduler.rst
+++ b/doc/source/devref/distributed_scheduler.rst
@@ -31,9 +31,9 @@ This is the purpose of the Distributed Scheduler (DS). The DS utilizes the Capab
 
 So, how does this all work?
 
-This document will explain the strategy employed by the `ZoneAwareScheduler` and its derivations. You should read the :doc:`devguide/zones` documentation before reading this.
+This document will explain the strategy employed by the `BaseScheduler`, which is the base for all schedulers designed to work across zones, and its derivations. You should read the :doc:`devguide/zones` documentation before reading this.
 
-    .. image:: /images/zone_aware_scheduler.png 
+    .. image:: /images/base_scheduler.png 
 
 Costs & Weights
 ---------------
@@ -52,32 +52,32 @@ This Weight is computed for each Instance requested. If the customer asked for 1
 
     .. image:: /images/costs_weights.png 
     
-nova.scheduler.zone_aware_scheduler.ZoneAwareScheduler
+nova.scheduler.base_scheduler.BaseScheduler
 ------------------------------------------------------
-As we explained in the Zones documentation, each Scheduler has a `ZoneManager` object that collects "Capabilities" about child Zones and each of the services running in the current Zone. The `ZoneAwareScheduler` uses this information to make its decisions.
+As we explained in the Zones documentation, each Scheduler has a `ZoneManager` object that collects "Capabilities" about child Zones and each of the services running in the current Zone. The `BaseScheduler` uses this information to make its decisions.
 
 Here is how it works:
 
  1. The compute nodes are filtered and the nodes remaining are weighed.
- 2. Filtering the hosts is a simple matter of ensuring the compute node has ample resources (CPU, RAM, Disk, etc) to fulfil the request. 
+ 2. Filtering the hosts is a simple matter of ensuring the compute node has ample resources (CPU, RAM, Disk, etc) to fulfil the request.
  3. Weighing of the remaining compute nodes assigns a number based on their suitability for the request.
  4. The same request is sent to each child Zone and step #1 is done there too. The resulting weighted list is returned to the parent.
  5. The parent Zone sorts and aggregates all the weights and a final build plan is constructed.
  6. The build plan is executed upon. Concurrently, instance create requests are sent to each of the selected hosts, be they local or in a child zone. Child Zones may forward the requests to their child Zones as needed.
 
-    .. image:: /images/zone_aware_overview.png 
+    .. image:: /images/zone_overview.png 
 
-`ZoneAwareScheduler` by itself is not capable of handling all the provisioning itself. Derived classes are used to select which host filtering and weighing strategy will be used.
+`BaseScheduler` by itself is not capable of handling all the provisioning itself. You should also specify the filter classes and weighting classes to be used in determining which host is selected for new instance creation.
 
 Filtering and Weighing
 ----------------------
-The filtering (excluding compute nodes incapable of fulfilling the request) and weighing (computing the relative "fitness" of a compute node to fulfill the request) rules used are very subjective operations ... Service Providers will probably have a very different set of filtering and weighing rules than private cloud administrators. The filtering and weighing aspects of the `ZoneAwareScheduler` are flexible and extensible.
+The filtering (excluding compute nodes incapable of fulfilling the request) and weighing (computing the relative "fitness" of a compute node to fulfill the request) rules used are very subjective operations ... Service Providers will probably have a very different set of filtering and weighing rules than private cloud administrators. The filtering and weighing aspects of the `BaseScheduler` are flexible and extensible.
 
     .. image:: /images/filtering.png 
 
 Requesting a new instance
 -------------------------
-Prior to the `ZoneAwareScheduler`, to request a new instance, a call was made to `nova.compute.api.create()`. The type of instance created depended on the value of the `InstanceType` record being passed in. The `InstanceType` determined the amount of disk, CPU, RAM and network required for the instance. Administrators can add new `InstanceType` records to suit their needs. For more complicated instance requests we need to go beyond the default fields in the `InstanceType` table.
+Prior to the `BaseScheduler`, to request a new instance, a call was made to `nova.compute.api.create()`. The type of instance created depended on the value of the `InstanceType` record being passed in. The `InstanceType` determined the amount of disk, CPU, RAM and network required for the instance. Administrators can add new `InstanceType` records to suit their needs. For more complicated instance requests we need to go beyond the default fields in the `InstanceType` table.
 
 `nova.compute.api.create()` performed the following actions:
  1. it validated all the fields passed into it.
@@ -89,11 +89,11 @@ Prior to the `ZoneAwareScheduler`, to request a new instance, a call was made to
 
     .. image:: /images/nova.compute.api.create.png 
 
-Generally, the standard schedulers (like `ChanceScheduler` and `AvailabilityZoneScheduler`) only operate in the current Zone. They have no concept of child Zones.
+Generally, the simplest schedulers (like `ChanceScheduler` and `AvailabilityZoneScheduler`) only operate in the current Zone. They have no concept of child Zones.
 
 The problem with this approach is each request is scattered amongst each of the schedulers. If we are asking for 1000 instances, each scheduler gets the requests one-at-a-time. There is no possability of optimizing the requests to take into account all 1000 instances as a group. We call this Single-Shot vs. All-at-Once. 
 
-For the `ZoneAwareScheduler` we need to use the All-at-Once approach. We need to consider all the hosts across all the Zones before deciding where they should reside. In order to handle this we have a new method `nova.compute.api.create_all_at_once()`. This method does things a little differently:
+For the `BaseScheduler` we need to use the All-at-Once approach. We need to consider all the hosts across all the Zones before deciding where they should reside. In order to handle this we have a new method `nova.compute.api.create_all_at_once()`. This method does things a little differently:
  1. it validates all the fields passed into it.
  2. it creates a single `reservation_id` for all of instances created. This is a UUID.
  3. it creates a single `run_instance` request in the scheduler queue
@@ -109,21 +109,19 @@ For the `ZoneAwareScheduler` we need to use the All-at-Once approach. We need to
 
 The Catch
 ---------
-This all seems pretty straightforward but, like most things, there's a catch. Zones are expected to operate in complete isolation from each other. Each Zone has its own AMQP service, database and set of Nova services. But, for security reasons Zones should never leak information about the architectural layout internally. That means Zones cannot leak information about hostnames or service IP addresses outside of its world.
+This all seems pretty straightforward but, like most things, there's a catch. Zones are expected to operate in complete isolation from each other. Each Zone has its own AMQP service, database and set of Nova services. But for security reasons Zones should never leak information about the architectural layout internally. That means Zones cannot leak information about hostnames or service IP addresses outside of its world.
 
-When `POST /zones/select` is called to estimate which compute node to use, time passes until the `POST /servers` call is issued. If we only passed the weight back from the `select` we would have to re-compute the appropriate compute node for the create command ... and we could end up with a different host. Somehow we need to remember the results of our computations and pass them outside of the Zone. Now, we could store this information in the local database and return a reference to it, but remember that the vast majority of weights are going to be ignored. Storing them in the database would result in a flood of disk access and then we have to clean up all these entries periodically. Recall that there are going to be many many `select` calls issued to child Zones asking for estimates. 
+When `POST /zones/select` is called to estimate which compute node to use, time passes until the `POST /servers` call is issued. If we only passed the weight back from the `select` we would have to re-compute the appropriate compute node for the create command ... and we could end up with a different host. Somehow we need to remember the results of our computations and pass them outside of the Zone. Now, we could store this information in the local database and return a reference to it, but remember that the vast majority of weights are going to be ignored. Storing them in the database would result in a flood of disk access and then we have to clean up all these entries periodically. Recall that there are going to be many, many `select` calls issued to child Zones asking for estimates. 
 
-Instead, we take a rather innovative approach to the problem. We encrypt all the child zone internal details and pass them back the to parent Zone. If the parent zone decides to use a child Zone for the instance it simply passes the encrypted data back to the child during the `POST /servers` call as an extra parameter. The child Zone can then decrypt the hint and go directly to the Compute node previously selected. If the estimate isn't used, it is simply discarded by the parent. It's for this reason that it is so important that each Zone defines a unique encryption key via `--build_plan_encryption_key`
+Instead, we take a rather innovative approach to the problem. We encrypt all the child Zone internal details and pass them back the to parent Zone. In the case of a nested Zone layout, each nesting layer will encrypt the data from all of its children and pass that to its parent Zone. In the case of nested child Zones, each Zone re-encrypts the weighted list results and passes those values to the parent. Every Zone interface adds another layer of encryption, using its unique key.
 
-In the case of nested child Zones, each Zone re-encrypts the weighted list results and passes those values to the parent.
+Once a host is selected, it will either be local to the Zone that received the initial API call, or one of its child Zones. In the latter case, the parent Zone it simply passes the encrypted data for the selected host back to each of its child Zones during the `POST /servers` call as an extra parameter. If the child Zone can decrypt the data, then it is the correct Zone for the selected host; all other Zones will not be able to decrypt the data and will discard the request. This is why it is critical that each Zone has a unique value specified in its config in `--build_plan_encryption_key`: it controls the ability to locate the selected host without having to hard-code path information or other identifying information. The child Zone can then act on the decrypted data and either go directly to the Compute node previously selected if it is located in that Zone, or repeat the process with its child Zones until the target Zone containing the selected host is reached.
 
-Throughout the `nova.api.openstack.servers`, `nova.api.openstack.zones`, `nova.compute.api.create*` and `nova.scheduler.zone_aware_scheduler` code you'll see references to `blob` and `child_blob`. These are the encrypted hints about which Compute node to use.
+Throughout the `nova.api.openstack.servers`, `nova.api.openstack.zones`, `nova.compute.api.create*` and `nova.scheduler.base_scheduler` code you'll see references to `blob` and `child_blob`. These are the encrypted hints about which Compute node to use.
 
 Reservation IDs
 ---------------
 
-NOTE: The features described in this section are related to the up-coming 'merge-4' branch. 
-
 The OpenStack API allows a user to list all the instances they own via the `GET /servers/` command or the details on a particular instance via `GET /servers/###`. This mechanism is usually sufficient since OS API only allows for creating one instance at a time, unlike the EC2 API which allows you to specify a quantity of instances to be created.
 
 NOTE: currently the `GET /servers` command is not Zone-aware since all operations done in child Zones are done via a single administrative account. Therefore, asking a child Zone to `GET /servers` would return all the active instances ... and that would not be what the user intended. Later, when the Keystone Auth system is integrated with Nova, this functionality will be enabled. 
@@ -137,23 +135,23 @@ Finally, we need to give the user a way to get information on each of the instan
 Host Filter
 -----------
 
-As we mentioned earlier, filtering hosts is a very deployment-specific process. Service Providers may have a different set of criteria for filtering Compute nodes than a University. To faciliate this the `nova.scheduler.host_filter` module supports a variety of filtering strategies as well as an easy means for plugging in your own algorithms.
+As we mentioned earlier, filtering hosts is a very deployment-specific process. Service Providers may have a different set of criteria for filtering Compute nodes than a University. To faciliate this the `nova.scheduler.filters` module supports a variety of filtering strategies as well as an easy means for plugging in your own algorithms.
 
-The filter used is determined by the `--default_host_filter` flag, which points to a Python Class. By default this flag is set to `nova.scheduler.host_filter.AllHostsFilter` which simply returns all available hosts. But there are others:
+The filter used is determined by the `--default_host_filters` flag, which points to a Python Class. By default this flag is set to `[AllHostsFilter]` which simply returns all available hosts. But there are others:
 
- * `nova.scheduler.host_filter.InstanceTypeFilter` provides host filtering based on the memory and disk size specified in the `InstanceType` record passed into `run_instance`. 
+ * `InstanceTypeFilter` provides host filtering based on the memory and disk size specified in the `InstanceType` record passed into `run_instance`. 
 
- * `nova.scheduler.host_filter.JSONFilter` filters hosts based on simple JSON expression grammar. Using a LISP-like JSON structure the caller can request instances based on criteria well beyond what `InstanceType` specifies. See `nova.tests.test_host_filter` for examples.
+ * `JSONFilter` filters hosts based on simple JSON expression grammar. Using a LISP-like JSON structure the caller can request instances based on criteria well beyond what `InstanceType` specifies. See `nova.tests.test_host_filter` for examples.
 
-To create your own `HostFilter` the user simply has to derive from `nova.scheduler.host_filter.HostFilter` and implement two methods: `instance_type_to_filter` and `filter_hosts`. Since Nova is currently dependent on the `InstanceType` structure, the `instance_type_to_filter` method should take an `InstanceType` and turn it into an internal data structure usable by your filter. This is for backward compatibility with existing OpenStack and EC2 API calls. If you decide to create your own call for creating instances not based on `Flavors` or `InstanceTypes` you can ignore this method. The real work is done in `filter_hosts` which must return a list of host tuples for each appropriate host. The set of all available hosts is in the `ZoneManager` object passed into the call as well as the filter query. The host tuple contains (`<hostname>`, `<additional data>`) where `<additional data>` is whatever you want it to be.
+To create your own `HostFilter` the user simply has to derive from `nova.scheduler.filters.AbstractHostFilter` and implement two methods: `instance_type_to_filter` and `filter_hosts`. Since Nova is currently dependent on the `InstanceType` structure, the `instance_type_to_filter` method should take an `InstanceType` and turn it into an internal data structure usable by your filter. This is for backward compatibility with existing OpenStack and EC2 API calls. If you decide to create your own call for creating instances not based on `Flavors` or `InstanceTypes` you can ignore this method. The real work is done in `filter_hosts` which must return a list of host tuples for each appropriate host. The set of available hosts is in the `host_list` parameter passed into the call as well as the filter query. The host tuple contains (`<hostname>`, `<additional data>`) where `<additional data>` is whatever you want it to be. By default, it is the capabilities reported by the host.
      
 Cost Scheduler Weighing
 -----------------------
-Every `ZoneAwareScheduler` derivation must also override the `weigh_hosts` method. This takes the list of filtered hosts (generated by the `filter_hosts` method) and returns a list of weight dicts. The weight dicts must contain two keys: `weight` and `hostname` where `weight` is simply an integer (lower is better) and `hostname` is the name of the host. The list does not need to be sorted, this will be done by the `ZoneAwareScheduler` base class when all the results have been assembled. 
+Every `BaseScheduler` subclass should also override the `weigh_hosts` method. This takes the list of filtered hosts (generated by the `filter_hosts` method) and returns a list of weight dicts. The weight dicts must contain two keys: `weight` and `hostname` where `weight` is simply an integer (lower is better) and `hostname` is the name of the host. The list does not need to be sorted, this will be done by the `BaseScheduler` when all the results have been assembled. 
 
-Simple Zone Aware Scheduling
+Simple Scheduling Across Zones
 ----------------------------
-The easiest way to get started with the `ZoneAwareScheduler` is to use the `nova.scheduler.host_filter.HostFilterScheduler`. This scheduler uses the default Host Filter and the `weight_hosts` method simply returns a weight of 1 for all hosts. But, from this, you can see calls being routed from Zone to Zone and follow the flow of things. 
+The `BaseScheduler` uses the default `filter_hosts` method, which will use either any filters specified in the request's `filter` parameter, or, if that is not specified, the filters specified in the `FLAGS.default_host_filters` setting. Its `weight_hosts` method simply returns a weight of 1 for all hosts. But, from this, you can see calls being routed from Zone to Zone and follow the flow of things. 
 
 The `--scheduler_driver` flag is how you specify the scheduler class name.
 
@@ -168,14 +166,14 @@ All this Zone and Distributed Scheduler stuff can seem a little daunting to conf
   --enable_zone_routing=true
   --zone_name=zone1
   --build_plan_encryption_key=c286696d887c9aa0611bbb3e2025a45b
-  --scheduler_driver=nova.scheduler.host_filter.HostFilterScheduler
-  --default_host_filter=nova.scheduler.host_filter.AllHostsFilter
+  --scheduler_driver=nova.scheduler.base_scheduler.BaseScheduler
+  --default_host_filter=nova.scheduler.filters.AllHostsFilter
 
 `--allow_admin_api` must be set for OS API to enable the new `/zones/*` commands.
 `--enable_zone_routing` must be set for OS API commands such as `create()`, `pause()` and `delete()` to get routed from Zone to Zone when looking for instances. 
 `--zone_name` is only required in child Zones. The default Zone name is `nova`, but you may want to name your child Zones something useful. Duplicate Zone names are not an issue.
 `build_plan_encryption_key` is the SHA-256 key for encrypting/decrypting the Host information when it leaves a Zone. Be sure to change this key for each Zone you create. Do not duplicate keys.
-`scheduler_driver` is the real workhorse of the operation. For Distributed Scheduler, you need to specify a class derived from `nova.scheduler.zone_aware_scheduler.ZoneAwareScheduler`.
+`scheduler_driver` is the real workhorse of the operation. For Distributed Scheduler, you need to specify a class derived from `nova.scheduler.base_scheduler.BaseScheduler`.
 `default_host_filter` is the host filter to be used for filtering candidate Compute nodes. 
 
 Some optional flags which are handy for debugging are:
diff --git a/doc/source/images/base_scheduler.png b/doc/source/images/base_scheduler.png
new file mode 100644
index 000000000..75d029338
--- /dev/null
+++ b/doc/source/images/base_scheduler.png
diff --git a/doc/source/images/zone_overview.png b/doc/source/images/zone_overview.png
new file mode 100755
index 000000000..cc891df0a
--- /dev/null
+++ b/doc/source/images/zone_overview.png
diff --git a/etc/nova/api-paste.ini b/etc/nova/api-paste.ini
index abe8c20c4..b540509a2 100644
--- a/etc/nova/api-paste.ini
+++ b/etc/nova/api-paste.ini
@@ -20,7 +20,8 @@ use = egg:Paste#urlmap
 
 [pipeline:ec2cloud]
 pipeline = logrequest authenticate cloudrequest authorizer ec2executor
-#pipeline = logrequest ec2lockout authenticate cloudrequest authorizer ec2executor
+# NOTE(vish): use the following pipeline for keystone
+# pipeline = logrequest totoken authtoken keystonecontext cloudrequest authorizer ec2executor
 
 [pipeline:ec2admin]
 pipeline = logrequest authenticate adminrequest authorizer ec2executor
@@ -37,6 +38,9 @@ paste.filter_factory = nova.api.ec2:RequestLogging.factory
 [filter:ec2lockout]
 paste.filter_factory = nova.api.ec2:Lockout.factory
 
+[filter:totoken]
+paste.filter_factory = nova.api.ec2:ToToken.factory
+
 [filter:authenticate]
 paste.filter_factory = nova.api.ec2:Authenticate.factory
 
@@ -72,9 +76,13 @@ use = egg:Paste#urlmap
 
 [pipeline:openstackapi10]
 pipeline = faultwrap auth ratelimit osapiapp10
+# NOTE(vish): use the following pipeline for keystone
+#pipeline = faultwrap authtoken keystonecontext ratelimit osapiapp10
 
 [pipeline:openstackapi11]
 pipeline = faultwrap auth ratelimit extensions osapiapp11
+# NOTE(vish): use the following pipeline for keystone
+# pipeline = faultwrap authtoken keystonecontext ratelimit extensions osapiapp11
 
 [filter:faultwrap]
 paste.filter_factory = nova.api.openstack:FaultWrapper.factory
@@ -99,3 +107,22 @@ pipeline = faultwrap osversionapp
 
 [app:osversionapp]
 paste.app_factory = nova.api.openstack.versions:Versions.factory
+
+##########
+# Shared #
+##########
+
+[filter:keystonecontext]
+paste.filter_factory = nova.api.auth:KeystoneContext.factory
+
+[filter:authtoken]
+paste.filter_factory = keystone.middleware.auth_token:filter_factory
+service_protocol = http
+service_host = 127.0.0.1
+service_port = 808
+auth_host = 127.0.0.1
+auth_port = 5001
+auth_protocol = http
+auth_uri = http://127.0.0.1:5000/
+admin_token = 999888777666
+
diff --git a/nova/api/auth.py b/nova/api/auth.py
new file mode 100644
index 000000000..cd3e3e8a0
--- /dev/null
+++ b/nova/api/auth.py
@@ -0,0 +1,75 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 OpenStack, LLC
+#
+#    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 Auth Middleware.
+
+"""
+
+import webob.dec
+import webob.exc
+
+from nova import context
+from nova import flags
+from nova import wsgi
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_boolean('use_forwarded_for', False,
+                     'Treat X-Forwarded-For as the canonical remote address. '
+                     'Only enable this if you have a sanitizing proxy.')
+
+
+class InjectContext(wsgi.Middleware):
+    """Add a 'nova.context' to WSGI environ."""
+
+    def __init__(self, context, *args, **kwargs):
+        self.context = context
+        super(InjectContext, self).__init__(*args, **kwargs)
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        req.environ['nova.context'] = self.context
+        return self.application
+
+
+class KeystoneContext(wsgi.Middleware):
+    """Make a request context from keystone headers"""
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        try:
+            user_id = req.headers['X_USER']
+        except KeyError:
+            return webob.exc.HTTPUnauthorized()
+        # get the roles
+        roles = [r.strip() for r in req.headers.get('X_ROLE', '').split(',')]
+        project_id = req.headers['X_TENANT']
+        # Get the auth token
+        auth_token = req.headers.get('X_AUTH_TOKEN',
+                                     req.headers.get('X_STORAGE_TOKEN'))
+
+        # Build a context, including the auth_token...
+        remote_address = req.remote_addr
+        if FLAGS.use_forwarded_for:
+            remote_address = req.headers.get('X-Forwarded-For', remote_address)
+        ctx = context.RequestContext(user_id,
+                                     project_id,
+                                     roles=roles,
+                                     auth_token=auth_token,
+                                     remote_address=remote_address)
+
+        req.environ['nova.context'] = ctx
+        return self.application
diff --git a/nova/api/ec2/__init__.py b/nova/api/ec2/__init__.py
index 96df97393..17969099d 100644
--- a/nova/api/ec2/__init__.py
+++ b/nova/api/ec2/__init__.py
@@ -20,6 +20,7 @@ Starting point for routing EC2 requests.
 
 """
 
+import httplib2
 import webob
 import webob.dec
 import webob.exc
@@ -37,15 +38,16 @@ from nova.auth import manager
 
 FLAGS = flags.FLAGS
 LOG = logging.getLogger("nova.api")
-flags.DEFINE_boolean('use_forwarded_for', False,
-                     'Treat X-Forwarded-For as the canonical remote address. '
-                     'Only enable this if you have a sanitizing proxy.')
 flags.DEFINE_integer('lockout_attempts', 5,
                      'Number of failed auths before lockout.')
 flags.DEFINE_integer('lockout_minutes', 15,
                      'Number of minutes to lockout if triggered.')
 flags.DEFINE_integer('lockout_window', 15,
                      'Number of minutes for lockout window.')
+flags.DEFINE_string('keystone_ec2_url',
+                    'http://localhost:5000/v2.0/ec2tokens',
+                    'URL to get token from ec2 request.')
+flags.DECLARE('use_forwarded_for', 'nova.api.auth')
 
 
 class RequestLogging(wsgi.Middleware):
@@ -138,6 +140,49 @@ class Lockout(wsgi.Middleware):
         return res
 
 
+class ToToken(wsgi.Middleware):
+    """Authenticate an EC2 request with keystone and convert to token."""
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        # Read request signature and access id.
+        try:
+            signature = req.params['Signature']
+            access = req.params['AWSAccessKeyId']
+        except KeyError:
+            raise webob.exc.HTTPBadRequest()
+
+        # Make a copy of args for authentication and signature verification.
+        auth_params = dict(req.params)
+        # Not part of authentication args
+        auth_params.pop('Signature')
+
+        # Authenticate the request.
+        client = httplib2.Http()
+        creds = {'ec2Credentials': {'access': access,
+                                    'signature': signature,
+                                    'host': req.host,
+                                    'verb': req.method,
+                                    'path': req.path,
+                                    'params': auth_params,
+                                   }}
+        headers = {'Content-Type': 'application/json'},
+        resp, content = client.request(FLAGS.keystone_ec2_url,
+                                       'POST',
+                                       headers=headers,
+                                       body=utils.dumps(creds))
+        # NOTE(vish): We could save a call to keystone by
+        #             having keystone return token, tenant,
+        #             user, and roles from this call.
+        result = utils.loads(content)
+        # TODO(vish): check for errors
+        token_id = result['auth']['token']['id']
+
+        # Authenticated!
+        req.headers['X-Auth-Token'] = token_id
+        return self.application
+
+
 class Authenticate(wsgi.Middleware):
     """Authenticate an EC2 request and add 'nova.context' to WSGI environ."""
 
@@ -147,7 +192,7 @@ class Authenticate(wsgi.Middleware):
         try:
             signature = req.params['Signature']
             access = req.params['AWSAccessKeyId']
-        except KeyError, e:
+        except KeyError:
             raise webob.exc.HTTPBadRequest()
 
         # Make a copy of args for authentication and signature verification.
diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 87bba58c3..9aebf92e3 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -305,7 +305,7 @@ class CloudController(object):
                 'hostname': hostname,
                 'instance-action': 'none',
                 'instance-id': ec2_id,
-                'instance-type': instance_ref['instance_type'],
+                'instance-type': instance_ref['instance_type']['name'],
                 'local-hostname': hostname,
                 'local-ipv4': address,
                 'placement': {'availability-zone': availability_zone},
diff --git a/nova/api/ec2/metadatarequesthandler.py b/nova/api/ec2/metadatarequesthandler.py
index 1dc275c90..0198bf490 100644
--- a/nova/api/ec2/metadatarequesthandler.py
+++ b/nova/api/ec2/metadatarequesthandler.py
@@ -30,6 +30,7 @@ from nova.api.ec2 import cloud
 
 LOG = logging.getLogger('nova.api.ec2.metadata')
 FLAGS = flags.FLAGS
+flags.DECLARE('use_forwarded_for', 'nova.api.auth')
 
 
 class MetadataRequestHandler(wsgi.Application):
diff --git a/nova/api/openstack/common.py b/nova/api/openstack/common.py
index b2a675653..d9eb832f2 100644
--- a/nova/api/openstack/common.py
+++ b/nova/api/openstack/common.py
@@ -241,7 +241,8 @@ def check_img_metadata_quota_limit(context, metadata):
     quota_metadata = quota.allowed_metadata_items(context, num_metadata)
     if quota_metadata < num_metadata:
         expl = _("Image metadata limit exceeded")
-        raise webob.exc.HTTPBadRequest(explanation=expl)
+        raise webob.exc.HTTPRequestEntityTooLarge(explanation=expl,
+                                                headers={'Retry-After': 0})
 
 
 class MetadataXMLDeserializer(wsgi.XMLDeserializer):
diff --git a/nova/api/openstack/contrib/floating_ips.py b/nova/api/openstack/contrib/floating_ips.py
index 44b35c385..40086f778 100644
--- a/nova/api/openstack/contrib/floating_ips.py
+++ b/nova/api/openstack/contrib/floating_ips.py
@@ -15,8 +15,9 @@
 #    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
+import webob
 
+from nova import compute
 from nova import exception
 from nova import log as logging
 from nova import network
@@ -71,18 +72,22 @@ class FloatingIPController(object):
         try:
             floating_ip = self.network_api.get_floating_ip(context, id)
         except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
+            return faults.Fault(webob.exc.HTTPNotFound())
 
         return _translate_floating_ip_view(floating_ip)
 
     def index(self, req):
         context = req.environ['nova.context']
 
-        floating_ips = self.network_api.list_floating_ips(context)
+        try:
+            # FIXME(ja) - why does self.network_api.list_floating_ips raise?
+            floating_ips = self.network_api.list_floating_ips(context)
+        except exception.FloatingIpNotFoundForProject:
+            floating_ips = []
 
         return _translate_floating_ips_view(floating_ips)
 
-    def create(self, req):
+    def create(self, req, body=None):
         context = req.environ['nova.context']
 
         try:
@@ -95,63 +100,67 @@ class FloatingIPController(object):
             else:
                 raise
 
-        return {'allocated': {
-            "id": ip['id'],
-            "floating_ip": ip['address']}}
+        return _translate_floating_ip_view(ip)
 
     def delete(self, req, id):
         context = req.environ['nova.context']
-        ip = self.network_api.get_floating_ip(context, id)
+        floating_ip = self.network_api.get_floating_ip(context, id)
 
-        if 'fixed_ip' in ip:
-            self.disassociate(req, id)
+        if 'fixed_ip' in floating_ip:
+            self.network_api.disassociate_floating_ip(context,
+                                                      floating_ip['address'])
 
-        self.network_api.release_floating_ip(context, address=ip['address'])
+        self.network_api.release_floating_ip(context,
+                                             address=floating_ip['address'])
+        return webob.exc.HTTPAccepted()
 
-        return {'released': {
-            "id": ip['id'],
-            "floating_ip": ip['address']}}
+    def _get_ip_by_id(self, context, value):
+        """Checks that value is id and then returns its address."""
+        return self.network_api.get_floating_ip(context, value)['address']
 
-    def associate(self, req, id, body):
-        """ /floating_ips/{id}/associate  fixed ip in body """
-        context = req.environ['nova.context']
-        floating_ip = self._get_ip_by_id(context, id)
 
-        fixed_ip = body['associate_address']['fixed_ip']
+class Floating_ips(extensions.ExtensionDescriptor):
+    def __init__(self):
+        self.compute_api = compute.API()
+        self.network_api = network.API()
+        super(Floating_ips, self).__init__()
 
-        try:
-            self.network_api.associate_floating_ip(context,
-                                                   floating_ip, fixed_ip)
-        except rpc.RemoteError:
-            raise
-
-        return {'associated':
-                {
-                "floating_ip_id": id,
-                "floating_ip": floating_ip,
-                "fixed_ip": fixed_ip}}
-
-    def disassociate(self, req, id, body=None):
-        """ POST /floating_ips/{id}/disassociate """
+    def _add_floating_ip(self, input_dict, req, instance_id):
+        """Associate floating_ip to an instance."""
         context = req.environ['nova.context']
-        floating_ip = self.network_api.get_floating_ip(context, id)
-        address = floating_ip['address']
-        fixed_ip = floating_ip['fixed_ip']['address']
 
         try:
-            self.network_api.disassociate_floating_ip(context, address)
-        except rpc.RemoteError:
-            raise
+            address = input_dict['addFloatingIp']['address']
+        except TypeError:
+            msg = _("Missing parameter dict")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+        except KeyError:
+            msg = _("Address not specified")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
 
-        return {'disassociated': {'floating_ip': address,
-                                  'fixed_ip': fixed_ip}}
+        self.compute_api.associate_floating_ip(context, instance_id, address)
 
-    def _get_ip_by_id(self, context, value):
-        """Checks that value is id and then returns its address."""
-        return self.network_api.get_floating_ip(context, value)['address']
+        return webob.Response(status_int=202)
 
+    def _remove_floating_ip(self, input_dict, req, instance_id):
+        """Dissociate floating_ip from an instance."""
+        context = req.environ['nova.context']
+
+        try:
+            address = input_dict['removeFloatingIp']['address']
+        except TypeError:
+            msg = _("Missing parameter dict")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+        except KeyError:
+            msg = _("Address not specified")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        floating_ip = self.network_api.get_floating_ip_by_ip(context, address)
+        if 'fixed_ip' in floating_ip:
+            self.network_api.disassociate_floating_ip(context, address)
+
+        return webob.Response(status_int=202)
 
-class Floating_ips(extensions.ExtensionDescriptor):
     def get_name(self):
         return "Floating_ips"
 
@@ -172,9 +181,18 @@ class Floating_ips(extensions.ExtensionDescriptor):
 
         res = extensions.ResourceExtension('os-floating-ips',
                          FloatingIPController(),
-                         member_actions={
-                            'associate': 'POST',
-                            'disassociate': 'POST'})
+                         member_actions={})
         resources.append(res)
 
         return resources
+
+    def get_actions(self):
+        """Return the actions the extension adds, as required by contract."""
+        actions = [
+                extensions.ActionExtension("servers", "addFloatingIp",
+                                            self._add_floating_ip),
+                extensions.ActionExtension("servers", "removeFloatingIp",
+                                            self._remove_floating_ip),
+        ]
+
+        return actions
diff --git a/nova/api/openstack/contrib/quotas.py b/nova/api/openstack/contrib/quotas.py
new file mode 100644
index 000000000..459b71dfd
--- /dev/null
+++ b/nova/api/openstack/contrib/quotas.py
@@ -0,0 +1,100 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 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.
+
+import webob
+
+from nova import db
+from nova import exception
+from nova import quota
+from nova.api.openstack import extensions
+
+
+class QuotaSetsController(object):
+
+    def _format_quota_set(self, project_id, quota_set):
+        """Convert the quota object to a result dict"""
+
+        return {'quota_set': {
+            'id': str(project_id),
+            'metadata_items': quota_set['metadata_items'],
+            'injected_file_content_bytes':
+             quota_set['injected_file_content_bytes'],
+            'volumes': quota_set['volumes'],
+            'gigabytes': quota_set['gigabytes'],
+            'ram': quota_set['ram'],
+            'floating_ips': quota_set['floating_ips'],
+            'instances': quota_set['instances'],
+            'injected_files': quota_set['injected_files'],
+            'cores': quota_set['cores'],
+        }}
+
+    def show(self, req, id):
+        context = req.environ['nova.context']
+        try:
+            db.sqlalchemy.api.authorize_project_context(context, id)
+            return self._format_quota_set(id,
+                                        quota.get_project_quotas(context, id))
+        except exception.NotAuthorized:
+            return webob.Response(status_int=403)
+
+    def update(self, req, id, body):
+        context = req.environ['nova.context']
+        project_id = id
+        resources = ['metadata_items', 'injected_file_content_bytes',
+                'volumes', 'gigabytes', 'ram', 'floating_ips', 'instances',
+                'injected_files', 'cores']
+        for key in body['quota_set'].keys():
+            if key in resources:
+                value = int(body['quota_set'][key])
+                try:
+                    db.quota_update(context, project_id, key, value)
+                except exception.ProjectQuotaNotFound:
+                    db.quota_create(context, project_id, key, value)
+                except exception.AdminRequired:
+                    return webob.Response(status_int=403)
+        return {'quota_set': quota.get_project_quotas(context, project_id)}
+
+    def defaults(self, req, id):
+        return self._format_quota_set(id, quota._get_default_quotas())
+
+
+class Quotas(extensions.ExtensionDescriptor):
+
+    def get_name(self):
+        return "Quotas"
+
+    def get_alias(self):
+        return "os-quota-sets"
+
+    def get_description(self):
+        return "Quotas management support"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/quotas-sets/api/v1.1"
+
+    def get_updated(self):
+        return "2011-08-08T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = []
+
+        res = extensions.ResourceExtension('os-quota-sets',
+                                            QuotaSetsController(),
+                                            member_actions={'defaults': 'GET'})
+        resources.append(res)
+
+        return resources
diff --git a/nova/api/openstack/contrib/rescue.py b/nova/api/openstack/contrib/rescue.py
new file mode 100644
index 000000000..3de128895
--- /dev/null
+++ b/nova/api/openstack/contrib/rescue.py
@@ -0,0 +1,83 @@
+#   Copyright 2011 Openstack, LLC.
+#
+#   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.
+
+"""The rescue mode extension."""
+
+import webob
+from webob import exc
+
+from nova import compute
+from nova import log as logging
+from nova.api.openstack import extensions as exts
+from nova.api.openstack import faults
+
+
+LOG = logging.getLogger("nova.api.contrib.rescue")
+
+
+def wrap_errors(fn):
+    """"Ensure errors are not passed along."""
+    def wrapped(*args):
+        try:
+            fn(*args)
+        except Exception, e:
+            return faults.Fault(exc.HTTPInternalServerError())
+    return wrapped
+
+
+class Rescue(exts.ExtensionDescriptor):
+    """The Rescue controller for the OpenStack API."""
+    def __init__(self):
+        super(Rescue, self).__init__()
+        self.compute_api = compute.API()
+
+    @wrap_errors
+    def _rescue(self, input_dict, req, instance_id):
+        """Rescue an instance."""
+        context = req.environ["nova.context"]
+        self.compute_api.rescue(context, instance_id)
+
+        return webob.Response(status_int=202)
+
+    @wrap_errors
+    def _unrescue(self, input_dict, req, instance_id):
+        """Unrescue an instance."""
+        context = req.environ["nova.context"]
+        self.compute_api.unrescue(context, instance_id)
+
+        return webob.Response(status_int=202)
+
+    def get_name(self):
+        return "Rescue"
+
+    def get_alias(self):
+        return "os-rescue"
+
+    def get_description(self):
+        return "Instance rescue mode"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/rescue/api/v1.1"
+
+    def get_updated(self):
+        return "2011-08-18T00:00:00+00:00"
+
+    def get_actions(self):
+        """Return the actions the extension adds, as required by contract."""
+        actions = [
+                exts.ActionExtension("servers", "rescue", self._rescue),
+                exts.ActionExtension("servers", "unrescue", self._unrescue),
+        ]
+
+        return actions
diff --git a/nova/api/openstack/contrib/security_groups.py b/nova/api/openstack/contrib/security_groups.py
index 6c57fbb51..1fd64f3b8 100644
--- a/nova/api/openstack/contrib/security_groups.py
+++ b/nova/api/openstack/contrib/security_groups.py
@@ -25,10 +25,11 @@ from nova import db
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import rpc
 from nova.api.openstack import common
 from nova.api.openstack import extensions
 from nova.api.openstack import wsgi
-
+from nova.compute import power_state
 
 from xml.dom import minidom
 
@@ -73,33 +74,28 @@ class SecurityGroupController(object):
                     context, rule)]
         return security_group
 
-    def show(self, req, id):
-        """Return data about the given security group."""
-        context = req.environ['nova.context']
+    def _get_security_group(self, context, id):
         try:
             id = int(id)
             security_group = db.security_group_get(context, id)
         except ValueError:
-            msg = _("Security group id is not integer")
-            return exc.HTTPBadRequest(explanation=msg)
+            msg = _("Security group id should be integer")
+            raise exc.HTTPBadRequest(explanation=msg)
         except exception.NotFound as exp:
-            return exc.HTTPNotFound(explanation=unicode(exp))
+            raise exc.HTTPNotFound(explanation=unicode(exp))
+        return security_group
 
+    def show(self, req, id):
+        """Return data about the given security group."""
+        context = req.environ['nova.context']
+        security_group = self._get_security_group(context, id)
         return {'security_group': self._format_security_group(context,
                                                               security_group)}
 
     def delete(self, req, id):
         """Delete a security group."""
         context = req.environ['nova.context']
-        try:
-            id = int(id)
-            security_group = db.security_group_get(context, id)
-        except ValueError:
-            msg = _("Security group id is not integer")
-            return exc.HTTPBadRequest(explanation=msg)
-        except exception.SecurityGroupNotFound as exp:
-            return exc.HTTPNotFound(explanation=unicode(exp))
-
+        security_group = self._get_security_group(context, id)
         LOG.audit(_("Delete security group %s"), id, context=context)
         db.security_group_destroy(context, security_group.id)
 
@@ -226,9 +222,9 @@ class SecurityGroupRulesController(SecurityGroupController):
         security_group_rule = db.security_group_rule_create(context, values)
 
         self.compute_api.trigger_security_group_rules_refresh(context,
-                                      security_group_id=security_group['id'])
+                                    security_group_id=security_group['id'])
 
-        return {'security_group_rule': self._format_security_group_rule(
+        return {"security_group_rule": self._format_security_group_rule(
                                                         context,
                                                         security_group_rule)}
 
@@ -336,6 +332,11 @@ class SecurityGroupRulesController(SecurityGroupController):
 
 
 class Security_groups(extensions.ExtensionDescriptor):
+
+    def __init__(self):
+        self.compute_api = compute.API()
+        super(Security_groups, self).__init__()
+
     def get_name(self):
         return "SecurityGroups"
 
@@ -351,6 +352,82 @@ class Security_groups(extensions.ExtensionDescriptor):
     def get_updated(self):
         return "2011-07-21T00:00:00+00:00"
 
+    def _addSecurityGroup(self, input_dict, req, instance_id):
+        context = req.environ['nova.context']
+
+        try:
+            body = input_dict['addSecurityGroup']
+            group_name = body['name']
+            instance_id = int(instance_id)
+        except ValueError:
+            msg = _("Server id should be integer")
+            raise exc.HTTPBadRequest(explanation=msg)
+        except TypeError:
+            msg = _("Missing parameter dict")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+        except KeyError:
+            msg = _("Security group not specified")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        if not group_name or group_name.strip() == '':
+            msg = _("Security group name cannot be empty")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        try:
+            self.compute_api.add_security_group(context, instance_id,
+                                                group_name)
+        except exception.SecurityGroupNotFound as exp:
+            return exc.HTTPNotFound(explanation=unicode(exp))
+        except exception.InstanceNotFound as exp:
+            return exc.HTTPNotFound(explanation=unicode(exp))
+        except exception.Invalid as exp:
+            return exc.HTTPBadRequest(explanation=unicode(exp))
+
+        return exc.HTTPAccepted()
+
+    def _removeSecurityGroup(self, input_dict, req, instance_id):
+        context = req.environ['nova.context']
+
+        try:
+            body = input_dict['removeSecurityGroup']
+            group_name = body['name']
+            instance_id = int(instance_id)
+        except ValueError:
+            msg = _("Server id should be integer")
+            raise exc.HTTPBadRequest(explanation=msg)
+        except TypeError:
+            msg = _("Missing parameter dict")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+        except KeyError:
+            msg = _("Security group not specified")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        if not group_name or group_name.strip() == '':
+            msg = _("Security group name cannot be empty")
+            raise webob.exc.HTTPBadRequest(explanation=msg)
+
+        try:
+            self.compute_api.remove_security_group(context, instance_id,
+                                                   group_name)
+        except exception.SecurityGroupNotFound as exp:
+            return exc.HTTPNotFound(explanation=unicode(exp))
+        except exception.InstanceNotFound as exp:
+            return exc.HTTPNotFound(explanation=unicode(exp))
+        except exception.Invalid as exp:
+            return exc.HTTPBadRequest(explanation=unicode(exp))
+
+        return exc.HTTPAccepted()
+
+    def get_actions(self):
+        """Return the actions the extensions adds"""
+        actions = [
+                extensions.ActionExtension("servers", "addSecurityGroup",
+                                           self._addSecurityGroup),
+                extensions.ActionExtension("servers", "removeSecurityGroup",
+                                           self._removeSecurityGroup)
+                   ]
+        return actions
+
     def get_resources(self):
         resources = []
 
diff --git a/nova/api/openstack/contrib/virtual_interfaces.py b/nova/api/openstack/contrib/virtual_interfaces.py
new file mode 100644
index 000000000..dab61efc8
--- /dev/null
+++ b/nova/api/openstack/contrib/virtual_interfaces.py
@@ -0,0 +1,108 @@
+# Copyright (C) 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.
+
+"""The virtual interfaces extension."""
+
+from webob import exc
+import webob
+
+from nova import compute
+from nova import exception
+from nova import log as logging
+from nova.api.openstack import common
+from nova.api.openstack import extensions
+from nova.api.openstack import faults
+from nova.api.openstack import wsgi
+
+
+LOG = logging.getLogger("nova.api.virtual_interfaces")
+
+
+def _translate_vif_summary_view(_context, vif):
+    """Maps keys for VIF summary view."""
+    d = {}
+    d['id'] = vif['uuid']
+    d['mac_address'] = vif['address']
+    return d
+
+
+def _get_metadata():
+    metadata = {
+        "attributes": {
+                'virtual_interface': ["id", "mac_address"]}}
+    return metadata
+
+
+class ServerVirtualInterfaceController(object):
+    """The instance VIF API controller for the Openstack API.
+    """
+
+    def __init__(self):
+        self.compute_api = compute.API()
+        super(ServerVirtualInterfaceController, self).__init__()
+
+    def _items(self, req, server_id, entity_maker):
+        """Returns a list of VIFs, transformed through entity_maker."""
+        context = req.environ['nova.context']
+
+        try:
+            instance = self.compute_api.get(context, server_id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        vifs = instance['virtual_interfaces']
+        limited_list = common.limited(vifs, req)
+        res = [entity_maker(context, vif) for vif in limited_list]
+        return {'virtual_interfaces': res}
+
+    def index(self, req, server_id):
+        """Returns the list of VIFs for a given instance."""
+        return self._items(req, server_id,
+                           entity_maker=_translate_vif_summary_view)
+
+
+class Virtual_interfaces(extensions.ExtensionDescriptor):
+
+    def get_name(self):
+        return "VirtualInterfaces"
+
+    def get_alias(self):
+        return "virtual_interfaces"
+
+    def get_description(self):
+        return "Virtual interface support"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/virtual_interfaces/api/v1.1"
+
+    def get_updated(self):
+        return "2011-08-17T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = []
+
+        metadata = _get_metadata()
+        body_serializers = {
+            'application/xml': wsgi.XMLDictSerializer(metadata=metadata,
+                                                      xmlns=wsgi.XMLNS_V11)}
+        serializer = wsgi.ResponseSerializer(body_serializers, None)
+        res = extensions.ResourceExtension(
+            'os-virtual-interfaces',
+            controller=ServerVirtualInterfaceController(),
+            parent=dict(member_name='server', collection_name='servers'),
+            serializer=serializer)
+        resources.append(res)
+
+        return resources
diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 4e1da549e..339f260b9 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -111,6 +111,15 @@ class CreateInstanceHelper(object):
         if personality:
             injected_files = self._get_injected_files(personality)
 
+        sg_names = []
+        security_groups = server_dict.get('security_groups')
+        if security_groups is not None:
+            sg_names = [sg['name'] for sg in security_groups if sg.get('name')]
+        if not sg_names:
+            sg_names.append('default')
+
+        sg_names = list(set(sg_names))
+
         try:
             flavor_id = self.controller._flavor_id_from_req_data(body)
         except ValueError as error:
@@ -122,6 +131,7 @@ class CreateInstanceHelper(object):
             raise exc.HTTPBadRequest(explanation=msg)
 
         zone_blob = server_dict.get('blob')
+        user_data = server_dict.get('user_data')
         availability_zone = server_dict.get('availability_zone')
         name = server_dict['name']
         self._validate_server_name(name)
@@ -157,12 +167,16 @@ class CreateInstanceHelper(object):
                                   key_name=key_name,
                                   key_data=key_data,
                                   metadata=server_dict.get('metadata', {}),
+                                  access_ip_v4=server_dict.get('accessIPv4'),
+                                  access_ip_v6=server_dict.get('accessIPv6'),
                                   injected_files=injected_files,
                                   admin_password=password,
                                   zone_blob=zone_blob,
                                   reservation_id=reservation_id,
                                   min_count=min_count,
                                   max_count=max_count,
+                                  security_group=sg_names,
+                                  user_data=user_data,
                                   availability_zone=availability_zone))
         except quota.QuotaError as error:
             self._handle_quota_error(error)
@@ -172,6 +186,8 @@ class CreateInstanceHelper(object):
         except exception.FlavorNotFound as error:
             msg = _("Invalid flavorRef provided.")
             raise exc.HTTPBadRequest(explanation=msg)
+        except exception.SecurityGroupNotFound as error:
+            raise exc.HTTPBadRequest(explanation=unicode(error))
         # Let the caller deal with unhandled exceptions.
 
     def _handle_quota_error(self, error):
@@ -180,13 +196,20 @@ class CreateInstanceHelper(object):
         """
         if error.code == "OnsetFileLimitExceeded":
             expl = _("Personality file limit exceeded")
-            raise exc.HTTPBadRequest(explanation=expl)
+            raise exc.HTTPRequestEntityTooLarge(explanation=error.message,
+                                                headers={'Retry-After': 0})
         if error.code == "OnsetFilePathLimitExceeded":
             expl = _("Personality file path too long")
-            raise exc.HTTPBadRequest(explanation=expl)
+            raise exc.HTTPRequestEntityTooLarge(explanation=error.message,
+                                                headers={'Retry-After': 0})
         if error.code == "OnsetFileContentLimitExceeded":
             expl = _("Personality file content too long")
-            raise exc.HTTPBadRequest(explanation=expl)
+            raise exc.HTTPRequestEntityTooLarge(explanation=error.message,
+                                                headers={'Retry-After': 0})
+        if error.code == "InstanceLimitExceeded":
+            expl = _("Instance quotas have been exceeded")
+            raise exc.HTTPRequestEntityTooLarge(explanation=error.message,
+                                                headers={'Retry-After': 0})
         # if the original error is okay, just reraise it
         raise error
 
@@ -443,7 +466,8 @@ class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer):
         server = {}
         server_node = self.find_first_child_named(node, 'server')
 
-        attributes = ["name", "imageRef", "flavorRef", "adminPass"]
+        attributes = ["name", "imageRef", "flavorRef", "adminPass",
+                      "accessIPv4", "accessIPv6"]
         for attr in attributes:
             if server_node.getAttribute(attr):
                 server[attr] = server_node.getAttribute(attr)
@@ -456,6 +480,10 @@ class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer):
         if personality is not None:
             server["personality"] = personality
 
+        security_groups = self._extract_security_groups(server_node)
+        if security_groups is not None:
+            server["security_groups"] = security_groups
+
         return server
 
     def _extract_personality(self, server_node):
@@ -472,3 +500,18 @@ class ServerXMLDeserializerV11(wsgi.MetadataXMLDeserializer):
             return personality
         else:
             return None
+
+    def _extract_security_groups(self, server_node):
+        """Marshal the security_groups attribute of a parsed request"""
+        node = self.find_first_child_named(server_node, "security_groups")
+        if node is not None:
+            security_groups = []
+            for sg_node in self.find_children_named(node, "security_group"):
+                item = {}
+                name_node = self.find_first_child_named(sg_node, "name")
+                if name_node:
+                    item["name"] = self.extract_text(name_node)
+                    security_groups.append(item)
+            return security_groups
+        else:
+            return None
diff --git a/nova/api/openstack/schemas/v1.1/server.rng b/nova/api/openstack/schemas/v1.1/server.rng
new file mode 100644
index 000000000..dbd169a83
--- /dev/null
+++ b/nova/api/openstack/schemas/v1.1/server.rng
@@ -0,0 +1,50 @@
+<element name="server" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+  <attribute name="name">      <text/> </attribute>
+  <attribute name="id">      <text/> </attribute>
+  <attribute name="uuid"> <text/> </attribute>
+  <attribute name="updated">   <text/> </attribute>
+  <attribute name="created">   <text/> </attribute>
+  <attribute name="hostId">   <text/> </attribute>
+  <attribute name="accessIPv4">   <text/> </attribute>
+  <attribute name="accessIPv6">   <text/> </attribute>
+  <attribute name="status">   <text/> </attribute>
+  <optional>
+    <attribute name="progress">   <text/> </attribute>
+  </optional>
+  <optional>
+    <attribute name="adminPass">   <text/> </attribute>
+  </optional>
+  <zeroOrMore>
+    <externalRef href="../atom-link.rng"/>
+  </zeroOrMore>
+  <element name="image">
+    <attribute name="id"> <text/> </attribute>
+    <externalRef href="../atom-link.rng"/>
+  </element>
+  <element name="flavor">
+    <attribute name="id"> <text/> </attribute>
+    <externalRef href="../atom-link.rng"/>
+  </element>
+  <element name="metadata">
+    <zeroOrMore>
+      <element name="meta">
+        <attribute name="key"> <text/> </attribute>
+        <text/>
+      </element>
+    </zeroOrMore>
+  </element>
+  <element name="addresses">
+    <zeroOrMore>
+      <element name="network">
+        <attribute name="id"> <text/> </attribute>
+          <zeroOrMore>
+            <element name="ip">
+              <attribute name="version"> <text/> </attribute>
+              <attribute name="addr"> <text/> </attribute>
+            </element>
+          </zeroOrMore>
+      </element>
+    </zeroOrMore>
+  </element>
+</element>
diff --git a/nova/api/openstack/schemas/v1.1/servers.rng b/nova/api/openstack/schemas/v1.1/servers.rng
new file mode 100644
index 000000000..4e2bb8853
--- /dev/null
+++ b/nova/api/openstack/schemas/v1.1/servers.rng
@@ -0,0 +1,6 @@
+<element name="servers" xmlns="http://relaxng.org/ns/structure/1.0"
+         ns="http://docs.openstack.org/compute/api/v1.1">
+  <zeroOrMore>
+    <externalRef href="server.rng"/>
+  </zeroOrMore>
+</element>
diff --git a/nova/api/openstack/schemas/v1.1/servers_index.rng b/nova/api/openstack/schemas/v1.1/servers_index.rng
new file mode 100644
index 000000000..768f0912d
--- /dev/null
+++ b/nova/api/openstack/schemas/v1.1/servers_index.rng
@@ -0,0 +1,12 @@
+<element name="servers" ns="http://docs.openstack.org/compute/api/v1.1"
+    xmlns="http://relaxng.org/ns/structure/1.0">
+  <zeroOrMore>
+    <element name="server">
+      <attribute name="name"> <text/> </attribute>
+      <attribute name="id"> <text/> </attribute>
+      <zeroOrMore>
+        <externalRef href="../atom-link.rng"/>
+      </zeroOrMore>
+    </element>
+  </zeroOrMore>
+</element>
diff --git a/nova/api/openstack/server_metadata.py b/nova/api/openstack/server_metadata.py
index 2b235f79a..8ac3319c9 100644
--- a/nova/api/openstack/server_metadata.py
+++ b/nova/api/openstack/server_metadata.py
@@ -151,7 +151,8 @@ class Controller(object):
     def _handle_quota_error(self, error):
         """Reraise quota errors as api-specific http exceptions."""
         if error.code == "MetadataLimitExceeded":
-            raise exc.HTTPBadRequest(explanation=error.message)
+            raise exc.HTTPRequestEntityTooLarge(explanation=error.message,
+                                                headers={'Retry-After': 0})
         raise error
 
 
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 335ecad86..1d1975a1c 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -163,7 +163,7 @@ class Controller(object):
 
     @scheduler_api.redirect_handler
     def update(self, req, id, body):
-        """Update server name then pass on to version-specific controller"""
+        """Update server then pass on to version-specific controller"""
         if len(req.body) == 0:
             raise exc.HTTPUnprocessableEntity()
 
@@ -178,6 +178,14 @@ class Controller(object):
             self.helper._validate_server_name(name)
             update_dict['display_name'] = name.strip()
 
+        if 'accessIPv4' in body['server']:
+            access_ipv4 = body['server']['accessIPv4']
+            update_dict['access_ip_v4'] = access_ipv4.strip()
+
+        if 'accessIPv6' in body['server']:
+            access_ipv6 = body['server']['accessIPv6']
+            update_dict['access_ip_v6'] = access_ipv6.strip()
+
         try:
             self.compute_api.update(ctxt, id, **update_dict)
         except exception.NotFound:
@@ -837,6 +845,10 @@ class ServerXMLSerializer(wsgi.XMLDictSerializer):
         node.setAttribute('created', str(server['created']))
         node.setAttribute('updated', str(server['updated']))
         node.setAttribute('status', server['status'])
+        if 'accessIPv4' in server:
+            node.setAttribute('accessIPv4', str(server['accessIPv4']))
+        if 'accessIPv6' in server:
+            node.setAttribute('accessIPv6', str(server['accessIPv6']))
         if 'progress' in server:
             node.setAttribute('progress', str(server['progress']))
 
@@ -923,6 +935,12 @@ class ServerXMLSerializer(wsgi.XMLDictSerializer):
         node.setAttribute('adminPass', server_dict['server']['adminPass'])
         return self.to_xml_string(node, True)
 
+    def update(self, server_dict):
+        xml_doc = minidom.Document()
+        node = self._server_to_xml_detailed(xml_doc,
+                                       server_dict['server'])
+        return self.to_xml_string(node, True)
+
 
 def create_resource(version='1.0'):
     controller = {
diff --git a/nova/api/openstack/views/servers.py b/nova/api/openstack/views/servers.py
index 8222f6766..d2c1b0ba1 100644
--- a/nova/api/openstack/views/servers.py
+++ b/nova/api/openstack/views/servers.py
@@ -111,14 +111,14 @@ class ViewBuilderV10(ViewBuilder):
         response['uuid'] = inst['uuid']
 
     def _build_image(self, response, inst):
-        if 'image_ref' in dict(inst):
+        if inst.get('image_ref', None):
             image_ref = inst['image_ref']
             if str(image_ref).startswith('http'):
                 raise exception.ListingImageRefsNotSupported()
             response['imageId'] = int(image_ref)
 
     def _build_flavor(self, response, inst):
-        if 'instance_type' in dict(inst):
+        if inst.get('instance_type', None):
             response['flavorId'] = inst['instance_type']['flavorid']
 
     def _build_addresses(self, response, inst):
@@ -143,10 +143,14 @@ class ViewBuilderV11(ViewBuilder):
                 response['server']['progress'] = 100
             elif response['server']['status'] == "BUILD":
                 response['server']['progress'] = 0
+
+        response['server']['accessIPv4'] = inst.get('access_ip_v4') or ""
+        response['server']['accessIPv6'] = inst.get('access_ip_v6') or ""
+
         return response
 
     def _build_image(self, response, inst):
-        if 'image_ref' in dict(inst):
+        if inst.get("image_ref", None):
             image_href = inst['image_ref']
             image_id = str(common.get_id_from_href(image_href))
             _bookmark = self.image_builder.generate_bookmark(image_id)
@@ -161,7 +165,7 @@ class ViewBuilderV11(ViewBuilder):
             }
 
     def _build_flavor(self, response, inst):
-        if "instance_type" in dict(inst):
+        if inst.get("instance_type", None):
             flavor_id = inst["instance_type"]['flavorid']
             flavor_ref = self.flavor_builder.generate_href(flavor_id)
             flavor_bookmark = self.flavor_builder.generate_bookmark(flavor_id)
diff --git a/nova/compute/api.py b/nova/compute/api.py
index e909e9959..d3cce8568 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -153,7 +153,7 @@ class API(base.Base):
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata=None,
                injected_files=None, admin_password=None, zone_blob=None,
-               reservation_id=None):
+               reservation_id=None, access_ip_v4=None, access_ip_v6=None):
         """Verify all the input parameters regardless of the provisioning
         strategy being performed."""
 
@@ -247,6 +247,8 @@ class API(base.Base):
             'key_data': key_data,
             'locked': False,
             'metadata': metadata,
+            'access_ip_v4': access_ip_v4,
+            'access_ip_v6': access_ip_v6,
             'availability_zone': availability_zone,
             'os_type': os_type,
             'architecture': architecture,
@@ -411,12 +413,11 @@ class API(base.Base):
             LOG.debug(_("Casting to scheduler for %(pid)s/%(uid)s's"
                     " (all-at-once)") % locals())
 
-        filter_class = 'nova.scheduler.host_filter.InstanceTypeFilter'
         request_spec = {
             'image': image,
             'instance_properties': base_options,
             'instance_type': instance_type,
-            'filter': filter_class,
+            'filter': None,
             'blob': zone_blob,
             'num_instances': num_instances,
         }
@@ -438,7 +439,8 @@ class API(base.Base):
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata=None,
                injected_files=None, admin_password=None, zone_blob=None,
-               reservation_id=None, block_device_mapping=None):
+               reservation_id=None, block_device_mapping=None,
+               access_ip_v4=None, access_ip_v6=None):
         """Provision the instances by passing the whole request to
         the Scheduler for execution. Returns a Reservation ID
         related to the creation of all of these instances."""
@@ -454,7 +456,7 @@ class API(base.Base):
                                key_name, key_data, security_group,
                                availability_zone, user_data, metadata,
                                injected_files, admin_password, zone_blob,
-                               reservation_id)
+                               reservation_id, access_ip_v4, access_ip_v6)
 
         self._ask_scheduler_to_create_instance(context, base_options,
                                       instance_type, zone_blob,
@@ -472,7 +474,8 @@ class API(base.Base):
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata=None,
                injected_files=None, admin_password=None, zone_blob=None,
-               reservation_id=None, block_device_mapping=None):
+               reservation_id=None, block_device_mapping=None,
+               access_ip_v4=None, access_ip_v6=None):
         """
         Provision the instances by sending off a series of single
         instance requests to the Schedulers. This is fine for trival
@@ -496,7 +499,7 @@ class API(base.Base):
                                key_name, key_data, security_group,
                                availability_zone, user_data, metadata,
                                injected_files, admin_password, zone_blob,
-                               reservation_id)
+                               reservation_id, access_ip_v4, access_ip_v6)
 
         block_device_mapping = block_device_mapping or []
         instances = []
@@ -614,6 +617,78 @@ class API(base.Base):
                      self.db.queue_get_for(context, FLAGS.compute_topic, host),
                      {'method': 'refresh_provider_fw_rules', 'args': {}})
 
+    def _is_security_group_associated_with_server(self, security_group,
+                                                instance_id):
+        """Check if the security group is already associated
+           with the instance. If Yes, return True.
+        """
+
+        if not security_group:
+            return False
+
+        instances = security_group.get('instances')
+        if not instances:
+            return False
+
+        inst_id = None
+        for inst_id in (instance['id'] for instance in instances \
+                        if instance_id == instance['id']):
+            return True
+
+        return False
+
+    def add_security_group(self, context, instance_id, security_group_name):
+        """Add security group to the instance"""
+        security_group = db.security_group_get_by_name(context,
+                                                       context.project_id,
+                                                       security_group_name)
+        # check if the server exists
+        inst = db.instance_get(context, instance_id)
+        #check if the security group is associated with the server
+        if self._is_security_group_associated_with_server(security_group,
+                                                        instance_id):
+            raise exception.SecurityGroupExistsForInstance(
+                                        security_group_id=security_group['id'],
+                                        instance_id=instance_id)
+
+        #check if the instance is in running state
+        if inst['state'] != power_state.RUNNING:
+            raise exception.InstanceNotRunning(instance_id=instance_id)
+
+        db.instance_add_security_group(context.elevated(),
+                                       instance_id,
+                                       security_group['id'])
+        rpc.cast(context,
+             db.queue_get_for(context, FLAGS.compute_topic, inst['host']),
+             {"method": "refresh_security_group_rules",
+              "args": {"security_group_id": security_group['id']}})
+
+    def remove_security_group(self, context, instance_id, security_group_name):
+        """Remove the security group associated with the instance"""
+        security_group = db.security_group_get_by_name(context,
+                                                       context.project_id,
+                                                       security_group_name)
+        # check if the server exists
+        inst = db.instance_get(context, instance_id)
+        #check if the security group is associated with the server
+        if not self._is_security_group_associated_with_server(security_group,
+                                                        instance_id):
+            raise exception.SecurityGroupNotExistsForInstance(
+                                    security_group_id=security_group['id'],
+                                    instance_id=instance_id)
+
+        #check if the instance is in running state
+        if inst['state'] != power_state.RUNNING:
+            raise exception.InstanceNotRunning(instance_id=instance_id)
+
+        db.instance_remove_security_group(context.elevated(),
+                                       instance_id,
+                                       security_group['id'])
+        rpc.cast(context,
+             db.queue_get_for(context, FLAGS.compute_topic, inst['host']),
+             {"method": "refresh_security_group_rules",
+              "args": {"security_group_id": security_group['id']}})
+
     @scheduler_api.reroute_compute("update")
     def update(self, context, instance_id, **kwargs):
         """Updates the instance in the datastore.
@@ -1068,15 +1143,21 @@ class API(base.Base):
         """Unpause the given instance."""
         self._cast_compute_message('unpause_instance', context, instance_id)
 
+    def _call_compute_message_for_host(self, action, context, host, params):
+        """Call method deliberately designed to make host/service only calls"""
+        queue = self.db.queue_get_for(context, FLAGS.compute_topic, host)
+        kwargs = {'method': action, 'args': params}
+        return rpc.call(context, queue, kwargs)
+
     def set_host_enabled(self, context, host, enabled):
         """Sets the specified host's ability to accept new instances."""
-        return self._call_compute_message("set_host_enabled", context,
+        return self._call_compute_message_for_host("set_host_enabled", context,
                 host=host, params={"enabled": enabled})
 
     def host_power_action(self, context, host, action):
         """Reboots, shuts down or powers up the host."""
-        return self._call_compute_message("host_power_action", context,
-                host=host, params={"action": action})
+        return self._call_compute_message_for_host("host_power_action",
+                context, host=host, params={"action": action})
 
     @scheduler_api.reroute_compute("diagnostics")
     def get_diagnostics(self, context, instance_id):
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 3299268f2..091b3b6b2 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -359,6 +359,13 @@ class ComputeManager(manager.SchedulerDependentManager):
             instance_type = self.db.instance_type_get(context,
                     instance_type_id)
             allowed_size_gb = instance_type['local_gb']
+
+            # NOTE(jk0): Since libvirt uses local_gb as a secondary drive, we
+            # need to handle potential situations where local_gb is 0. This is
+            # the default for m1.tiny.
+            if allowed_size_gb == 0:
+                return
+
             allowed_size_bytes = allowed_size_gb * 1024 * 1024 * 1024
 
             LOG.debug(_("image_id=%(image_id)d, image_size_bytes="
@@ -385,12 +392,12 @@ class ComputeManager(manager.SchedulerDependentManager):
         updates = {}
         updates['host'] = self.host
         updates['launched_on'] = self.host
-        # NOTE(vish): used by virt but not in database
-        updates['injected_files'] = kwargs.get('injected_files', [])
-        updates['admin_pass'] = kwargs.get('admin_password', None)
         instance = self.db.instance_update(context,
                                            instance_id,
                                            updates)
+        instance['injected_files'] = kwargs.get('injected_files', [])
+        instance['admin_pass'] = kwargs.get('admin_password', None)
+
         self.db.instance_set_state(context,
                                    instance_id,
                                    power_state.NOSTATE,
@@ -1368,7 +1375,8 @@ class ComputeManager(manager.SchedulerDependentManager):
         # This nwfilter is necessary on the destination host.
         # In addition, this method is creating filtering rule
         # onto destination host.
-        self.driver.ensure_filtering_rules_for_instance(instance_ref, network_info)
+        self.driver.ensure_filtering_rules_for_instance(instance_ref,
+                network_info)
 
         # Preparation for block migration
         if block_migration:
diff --git a/nova/db/api.py b/nova/db/api.py
index b9ea8757c..e946e8436 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -570,6 +570,12 @@ def instance_add_security_group(context, instance_id, security_group_id):
                                             security_group_id)
 
 
+def instance_remove_security_group(context, instance_id, security_group_id):
+    """Disassociate the given security group from the given instance."""
+    return IMPL.instance_remove_security_group(context, instance_id,
+                                            security_group_id)
+
+
 def instance_action_create(context, values):
     """Create an instance action from the values dictionary."""
     return IMPL.instance_action_create(context, values)
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index 57a4370d8..0f747c602 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -1178,6 +1178,19 @@ def instance_get_all_by_filters(context, filters):
                         return True
         return False
 
+    def _regexp_filter_by_metadata(instance, meta):
+        inst_metadata = [{node['key']: node['value']} \
+                         for node in instance['metadata']]
+        if isinstance(meta, list):
+            for node in meta:
+                if node not in inst_metadata:
+                    return False
+        elif isinstance(meta, dict):
+            for k, v in meta.iteritems():
+                if {k: v} not in inst_metadata:
+                    return False
+        return True
+
     def _regexp_filter_by_column(instance, filter_name, filter_re):
         try:
             v = getattr(instance, filter_name)
@@ -1209,7 +1222,8 @@ def instance_get_all_by_filters(context, filters):
                    options(joinedload('security_groups')).\
                    options(joinedload_all('fixed_ips.network')).\
                    options(joinedload('metadata')).\
-                   options(joinedload('instance_type'))
+                   options(joinedload('instance_type')).\
+                   filter_by(deleted=can_read_deleted(context))
 
     # Make a copy of the filters dictionary to use going forward, as we'll
     # be modifying it and we shouldn't affect the caller's use of it.
@@ -1236,7 +1250,9 @@ def instance_get_all_by_filters(context, filters):
         query_prefix = _exact_match_filter(query_prefix, filter_name,
                 filters.pop(filter_name))
 
-    instances = query_prefix.all()
+    instances = query_prefix.\
+                    filter_by(deleted=can_read_deleted(context)).\
+                    all()
 
     if not instances:
         return []
@@ -1252,6 +1268,9 @@ def instance_get_all_by_filters(context, filters):
         filter_re = re.compile(str(filters[filter_name]))
         if filter_func:
             filter_l = lambda instance: filter_func(instance, filter_re)
+        elif filter_name == 'metadata':
+            filter_l = lambda instance: _regexp_filter_by_metadata(instance,
+                    filters[filter_name])
         else:
             filter_l = lambda instance: _regexp_filter_by_column(instance,
                     filter_name, filter_re)
@@ -1483,6 +1502,19 @@ def instance_add_security_group(context, instance_id, security_group_id):
 
 
 @require_context
+def instance_remove_security_group(context, instance_id, security_group_id):
+    """Disassociate the given security group from the given instance"""
+    session = get_session()
+
+    session.query(models.SecurityGroupInstanceAssociation).\
+                filter_by(instance_id=instance_id).\
+                filter_by(security_group_id=security_group_id).\
+                update({'deleted': True,
+                        'deleted_at': utils.utcnow(),
+                        'updated_at': literal_column('updated_at')})
+
+
+@require_context
 def instance_action_create(context, values):
     """Create an instance action from the values dictionary."""
     action_ref = models.InstanceActions()
@@ -1959,6 +1991,7 @@ def quota_get(context, project_id, resource, session=None):
 
 @require_context
 def quota_get_all_by_project(context, project_id):
+    authorize_project_context(context, project_id)
     session = get_session()
     result = {'project_id': project_id}
     rows = session.query(models.Quota).\
@@ -2417,6 +2450,7 @@ def security_group_get(context, security_group_id, session=None):
                          filter_by(deleted=can_read_deleted(context),).\
                          filter_by(id=security_group_id).\
                          options(joinedload_all('rules')).\
+                         options(joinedload_all('instances')).\
                          first()
     else:
         result = session.query(models.SecurityGroup).\
@@ -2424,6 +2458,7 @@ def security_group_get(context, security_group_id, session=None):
                          filter_by(id=security_group_id).\
                          filter_by(project_id=context.project_id).\
                          options(joinedload_all('rules')).\
+                         options(joinedload_all('instances')).\
                          first()
     if not result:
         raise exception.SecurityGroupNotFound(
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/037_instances_drop_admin_pass.py b/nova/db/sqlalchemy/migrate_repo/versions/037_instances_drop_admin_pass.py
new file mode 100644
index 000000000..b957666c2
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/037_instances_drop_admin_pass.py
@@ -0,0 +1,37 @@
+# Copyright 2011 OpenStack LLC.
+#
+#    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 Column, MetaData, Table, String
+
+meta = MetaData()
+
+admin_pass = Column(
+    'admin_pass',
+    String(length=255, convert_unicode=False, assert_unicode=None,
+           unicode_error=None, _warn_on_bytestring=False),
+    nullable=True)
+
+
+def upgrade(migrate_engine):
+    meta.bind = migrate_engine
+    instances = Table('instances', meta, autoload=True,
+                      autoload_with=migrate_engine)
+    instances.drop_column('admin_pass')
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+    instances = Table('instances', meta, autoload=True,
+                      autoload_with=migrate_engine)
+    instances.create_column(admin_pass)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/038_add_uuid_to_virtual_interfaces.py b/nova/db/sqlalchemy/migrate_repo/versions/038_add_uuid_to_virtual_interfaces.py
new file mode 100644
index 000000000..0f542cbec
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/038_add_uuid_to_virtual_interfaces.py
@@ -0,0 +1,44 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (C) 2011 Midokura KK
+#
+#    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 Column, Integer, MetaData, String, Table
+
+from nova import utils
+
+
+meta = MetaData()
+
+virtual_interfaces = Table("virtual_interfaces", meta,
+                           Column("id", Integer(), primary_key=True,
+                                  nullable=False))
+uuid_column = Column("uuid", String(36))
+
+
+def upgrade(migrate_engine):
+    meta.bind = migrate_engine
+    virtual_interfaces.create_column(uuid_column)
+
+    rows = migrate_engine.execute(virtual_interfaces.select())
+    for row in rows:
+        vif_uuid = str(utils.gen_uuid())
+        migrate_engine.execute(virtual_interfaces.update()\
+                .where(virtual_interfaces.c.id == row[0])\
+                .values(uuid=vif_uuid))
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+    virtual_interfaces.drop_column(uuid_column)
diff --git a/nova/db/sqlalchemy/migrate_repo/versions/039_add_instances_accessip.py b/nova/db/sqlalchemy/migrate_repo/versions/039_add_instances_accessip.py
new file mode 100644
index 000000000..39f0dd6ce
--- /dev/null
+++ b/nova/db/sqlalchemy/migrate_repo/versions/039_add_instances_accessip.py
@@ -0,0 +1,48 @@
+# Copyright 2011 OpenStack LLC.
+#
+#    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 Column, Integer, MetaData, Table, String
+
+meta = MetaData()
+
+accessIPv4 = Column(
+    'access_ip_v4',
+    String(length=255, convert_unicode=False, assert_unicode=None,
+           unicode_error=None, _warn_on_bytestring=False),
+    nullable=True)
+
+accessIPv6 = Column(
+    'access_ip_v6',
+    String(length=255, convert_unicode=False, assert_unicode=None,
+           unicode_error=None, _warn_on_bytestring=False),
+    nullable=True)
+
+instances = Table('instances', meta,
+        Column('id', Integer(), primary_key=True, nullable=False),
+        )
+
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    instances.create_column(accessIPv4)
+    instances.create_column(accessIPv6)
+
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    meta.bind = migrate_engine
+    instances.drop_column('access_ip_v4')
+    instances.drop_column('access_ip_v6')
diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index f2a4680b0..a487ab28d 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -173,7 +173,6 @@ class Instance(BASE, NovaBase):
             base_name += "-rescue"
         return base_name
 
-    admin_pass = Column(String(255))
     user_id = Column(String(255))
     project_id = Column(String(255))
 
@@ -232,6 +231,11 @@ class Instance(BASE, NovaBase):
 
     root_device_name = Column(String(255))
 
+    # User editable field meant to represent what ip should be used
+    # to connect to the instance
+    access_ip_v4 = Column(String(255))
+    access_ip_v6 = Column(String(255))
+
     # TODO(vish): see Ewan's email about state improvements, probably
     #             should be in a driver base class or some such
     # vmstate_state = running, halted, suspended, paused
@@ -571,6 +575,8 @@ class VirtualInterface(BASE, NovaBase):
     instance_id = Column(Integer, ForeignKey('instances.id'), nullable=False)
     instance = relationship(Instance, backref=backref('virtual_interfaces'))
 
+    uuid = Column(String(36))
+
     @property
     def fixed_ipv6(self):
         cidr_v6 = self.network.cidr_v6
diff --git a/nova/db/sqlalchemy/session.py b/nova/db/sqlalchemy/session.py
index 07f281938..643e2338e 100644
--- a/nova/db/sqlalchemy/session.py
+++ b/nova/db/sqlalchemy/session.py
@@ -73,9 +73,11 @@ def get_engine():
 
     elif MySQLdb and "mysql" in connection_dict.drivername:
         LOG.info(_("Using mysql/eventlet db_pool."))
+        # MySQLdb won't accept 'None' in the password field
+        password = connection_dict.password or ''
         pool_args = {
             "db": connection_dict.database,
-            "passwd": connection_dict.password,
+            "passwd": password,
             "host": connection_dict.host,
             "user": connection_dict.username,
             "min_size": FLAGS.sql_min_pool_size,
diff --git a/nova/exception.py b/nova/exception.py
index b09d50797..e8cb7bcb5 100644
--- a/nova/exception.py
+++ b/nova/exception.py
@@ -541,6 +541,16 @@ class SecurityGroupNotFoundForRule(SecurityGroupNotFound):
     message = _("Security group with rule %(rule_id)s not found.")
 
 
+class SecurityGroupExistsForInstance(Invalid):
+    message = _("Security group %(security_group_id)s is already associated"
+                 " with the instance %(instance_id)s")
+
+
+class SecurityGroupNotExistsForInstance(Invalid):
+    message = _("Security group %(security_group_id)s is not associated with"
+                 " the instance %(instance_id)s")
+
+
 class MigrationNotFound(NotFound):
     message = _("Migration %(migration_id)s could not be found.")
 
diff --git a/nova/image/s3.py b/nova/image/s3.py
index ccbfa89cd..abf01a942 100644
--- a/nova/image/s3.py
+++ b/nova/image/s3.py
@@ -193,6 +193,8 @@ class S3ImageService(service.BaseImageService):
 
         def delayed_create():
             """This handles the fetching and decrypting of the part files."""
+            log_vars = {'image_location': image_location,
+                        'image_path': image_path}
             metadata['properties']['image_state'] = 'downloading'
             self.service.update(context, image_id, metadata)
 
@@ -213,11 +215,11 @@ class S3ImageService(service.BaseImageService):
                             shutil.copyfileobj(part, combined)
 
             except Exception:
-                LOG.error(_("Failed to download %(image_location)s "
-                            "to %(image_path)s"), locals())
+                LOG.exception(_("Failed to download %(image_location)s "
+                                "to %(image_path)s"), log_vars)
                 metadata['properties']['image_state'] = 'failed_download'
                 self.service.update(context, image_id, metadata)
-                raise
+                return
 
             metadata['properties']['image_state'] = 'decrypting'
             self.service.update(context, image_id, metadata)
@@ -237,11 +239,11 @@ class S3ImageService(service.BaseImageService):
                                     encrypted_iv, cloud_pk,
                                     dec_filename)
             except Exception:
-                LOG.error(_("Failed to decrypt %(image_location)s "
-                            "to %(image_path)s"), locals())
+                LOG.exception(_("Failed to decrypt %(image_location)s "
+                                "to %(image_path)s"), log_vars)
                 metadata['properties']['image_state'] = 'failed_decrypt'
                 self.service.update(context, image_id, metadata)
-                raise
+                return
 
             metadata['properties']['image_state'] = 'untarring'
             self.service.update(context, image_id, metadata)
@@ -249,11 +251,11 @@ class S3ImageService(service.BaseImageService):
             try:
                 unz_filename = self._untarzip_image(image_path, dec_filename)
             except Exception:
-                LOG.error(_("Failed to untar %(image_location)s "
-                            "to %(image_path)s"), locals())
+                LOG.exception(_("Failed to untar %(image_location)s "
+                                "to %(image_path)s"), log_vars)
                 metadata['properties']['image_state'] = 'failed_untar'
                 self.service.update(context, image_id, metadata)
-                raise
+                return
 
             metadata['properties']['image_state'] = 'uploading'
             self.service.update(context, image_id, metadata)
@@ -262,11 +264,11 @@ class S3ImageService(service.BaseImageService):
                     self.service.update(context, image_id,
                                         metadata, image_file)
             except Exception:
-                LOG.error(_("Failed to upload %(image_location)s "
-                            "to %(image_path)s"), locals())
+                LOG.exception(_("Failed to upload %(image_location)s "
+                                "to %(image_path)s"), log_vars)
                 metadata['properties']['image_state'] = 'failed_upload'
                 self.service.update(context, image_id, metadata)
-                raise
+                return
 
             metadata['properties']['image_state'] = 'available'
             metadata['status'] = 'active'
diff --git a/nova/network/linux_net.py b/nova/network/linux_net.py
index 4e1e1f85a..57c1d0c28 100644
--- a/nova/network/linux_net.py
+++ b/nova/network/linux_net.py
@@ -63,6 +63,11 @@ flags.DEFINE_string('dmz_cidr', '10.128.0.0/24',
                     'dmz range that should be accepted')
 flags.DEFINE_string('dnsmasq_config_file', "",
                     'Override the default dnsmasq settings with this file')
+flags.DEFINE_string('linuxnet_interface_driver',
+                    'nova.network.linux_net.LinuxBridgeInterfaceDriver',
+                    'Driver used to create ethernet devices.')
+flags.DEFINE_string('linuxnet_ovs_integration_bridge',
+                    'br-int', 'Name of Open vSwitch bridge used with linuxnet')
 binary_name = os.path.basename(inspect.stack()[-1][1])
 
 
@@ -414,7 +419,7 @@ def ensure_metadata_ip():
              run_as_root=True, check_exit_code=False)
 
 
-def ensure_vlan_forward(public_ip, port, private_ip):
+def ensure_vpn_forward(public_ip, port, private_ip):
     """Sets up forwarding rules for vlan."""
     iptables_manager.ipv4['filter'].add_rule('FORWARD',
                                              '-d %s -p udp '
@@ -452,111 +457,34 @@ def floating_forward_rules(floating_ip, fixed_ip):
              '-s %s -j SNAT --to %s' % (fixed_ip, floating_ip))]
 
 
-def ensure_vlan_bridge(vlan_num, bridge, bridge_interface, net_attrs=None):
-    """Create a vlan and bridge unless they already exist."""
-    interface = ensure_vlan(vlan_num, bridge_interface)
-    ensure_bridge(bridge, interface, net_attrs)
-    return interface
+def initialize_gateway_device(dev, network_ref):
+    if not network_ref:
+        return
 
-
-@utils.synchronized('ensure_vlan', external=True)
-def ensure_vlan(vlan_num, bridge_interface):
-    """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('vconfig', 'set_name_type', 'VLAN_PLUS_VID_NO_PAD',
-                 run_as_root=True)
-        _execute('vconfig', 'add', bridge_interface, vlan_num,
-                 run_as_root=True)
-        _execute('ip', 'link', 'set', interface, 'up', run_as_root=True)
-    return interface
-
-
-@utils.synchronized('ensure_bridge', external=True)
-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 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('brctl', 'addbr', bridge, run_as_root=True)
-        _execute('brctl', 'setfd', bridge, 0, run_as_root=True)
-        _execute('brctl', 'stp', bridge, 'off', run_as_root=True)
-        _execute('ip', 'link', 'set', bridge, 'up', run_as_root=True)
-    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('ip', 'addr', 'add',
+    # NOTE(vish): The ip for dnsmasq has to be the first address on the
+    #             bridge for it to respond to reqests properly
+    suffix = network_ref['cidr'].rpartition('/')[2]
+    out, err = _execute('ip', 'addr', 'add',
                             '%s/%s' %
-                            (net_attrs['dhcp_server'], suffix),
+                            (network_ref['dhcp_server'], suffix),
                             'brd',
-                            net_attrs['broadcast'],
+                            network_ref['broadcast'],
                             'dev',
-                            bridge,
+                            dev,
                             run_as_root=True,
                             check_exit_code=False)
-        if err and err != 'RTNETLINK answers: File exists\n':
-            raise exception.Error('Failed to add ip: %s' % err)
-        if(FLAGS.use_ipv6):
-            _execute('ip', '-f', 'inet6', 'addr',
-                     'change', net_attrs['cidr_v6'],
-                     'dev', bridge, run_as_root=True)
-        # 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.public_interface == bridge):
-            _execute('ip', 'link', 'set',
-                     'dev', bridge, 'promisc', 'on', run_as_root=True)
-    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('route', '-n', run_as_root=True)
-        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]
-                _execute('route', 'del', 'default', 'gw', gateway,
-                         'dev', interface,
-                         check_exit_code=False, run_as_root=True)
-        out, err = _execute('ip', 'addr', 'show', 'dev', interface,
-                            'scope', 'global', run_as_root=True)
-        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]),
-                         run_as_root=True)
-                _execute(*_ip_bridge_cmd('add', params, bridge),
-                         run_as_root=True)
-        if gateway:
-            _execute('route', 'add', 'default', 'gw', gateway,
-                     run_as_root=True)
-        out, err = _execute('brctl', 'addif', bridge, interface,
-                            check_exit_code=False, run_as_root=True)
-
-        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)
-
-    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)
+    if err and err != 'RTNETLINK answers: File exists\n':
+        raise exception.Error('Failed to add ip: %s' % err)
+    if(FLAGS.use_ipv6):
+        _execute('ip', '-f', 'inet6', 'addr',
+                     'change', network_ref['cidr_v6'],
+                     'dev', dev, run_as_root=True)
+    # 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.public_interface == dev):
+        _execute('ip', 'link', 'set',
+                     'dev', dev, 'promisc', 'on', run_as_root=True)
 
 
 def get_dhcp_leases(context, network_ref):
@@ -587,21 +515,21 @@ def get_dhcp_hosts(context, network_ref):
 #           configuration options (like dchp-range, vlan, ...)
 #           aren't reloaded.
 @utils.synchronized('dnsmasq_start')
-def update_dhcp(context, network_ref):
+def update_dhcp(context, dev, network_ref):
     """(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(network_ref['bridge'], 'conf')
+    conffile = _dhcp_file(dev, 'conf')
     with open(conffile, 'w') as f:
         f.write(get_dhcp_hosts(context, network_ref))
 
     # Make sure dnsmasq can actually read it (it setuid()s to "nobody")
     os.chmod(conffile, 0644)
 
-    pid = _dnsmasq_pid_for(network_ref['bridge'])
+    pid = _dnsmasq_pid_for(dev)
 
     # if dnsmasq is already running, then tell it to reload
     if pid:
@@ -617,19 +545,19 @@ def update_dhcp(context, network_ref):
             LOG.debug(_('Pid %d is stale, relaunching dnsmasq'), pid)
 
     cmd = ['FLAGFILE=%s' % FLAGS.dhcpbridge_flagfile,
-           'DNSMASQ_INTERFACE=%s' % network_ref['bridge'],
+           'NETWORK_ID=%s' % str(network_ref['id']),
            'dnsmasq',
            '--strict-order',
            '--bind-interfaces',
-           '--interface=%s' % network_ref['bridge'],
+           '--interface=%s' % dev,
            '--conf-file=%s' % FLAGS.dnsmasq_config_file,
            '--domain=%s' % FLAGS.dhcp_domain,
-           '--pid-file=%s' % _dhcp_file(network_ref['bridge'], 'pid'),
+           '--pid-file=%s' % _dhcp_file(dev, 'pid'),
            '--listen-address=%s' % network_ref['dhcp_server'],
            '--except-interface=lo',
            '--dhcp-range=%s,static,120s' % network_ref['dhcp_start'],
            '--dhcp-lease-max=%s' % len(netaddr.IPNetwork(network_ref['cidr'])),
-           '--dhcp-hostsfile=%s' % _dhcp_file(network_ref['bridge'], 'conf'),
+           '--dhcp-hostsfile=%s' % _dhcp_file(dev, 'conf'),
            '--dhcp-script=%s' % FLAGS.dhcpbridge,
            '--leasefile-ro']
     if FLAGS.dns_server:
@@ -639,8 +567,8 @@ def update_dhcp(context, network_ref):
 
 
 @utils.synchronized('radvd_start')
-def update_ra(context, network_ref):
-    conffile = _ra_file(network_ref['bridge'], 'conf')
+def update_ra(context, dev, network_ref):
+    conffile = _ra_file(dev, 'conf')
     with open(conffile, 'w') as f:
         conf_str = """
 interface %s
@@ -654,13 +582,13 @@ interface %s
         AdvAutonomous on;
    };
 };
-""" % (network_ref['bridge'], network_ref['cidr_v6'])
+""" % (dev, network_ref['cidr_v6'])
         f.write(conf_str)
 
     # Make sure radvd can actually read it (it setuid()s to "nobody")
     os.chmod(conffile, 0644)
 
-    pid = _ra_pid_for(network_ref['bridge'])
+    pid = _ra_pid_for(dev)
 
     # if radvd is already running, then tell it to reload
     if pid:
@@ -675,8 +603,8 @@ interface %s
             LOG.debug(_('Pid %d is stale, relaunching radvd'), pid)
 
     cmd = ['radvd',
-           '-C', '%s' % _ra_file(network_ref['bridge'], 'conf'),
-           '-p', '%s' % _ra_file(network_ref['bridge'], 'pid')]
+           '-C', '%s' % _ra_file(dev, 'conf'),
+           '-p', '%s' % _ra_file(dev, 'pid')]
 
     _execute(*cmd, run_as_root=True)
 
@@ -722,9 +650,9 @@ def _device_exists(device):
     return not err
 
 
-def _stop_dnsmasq(network):
+def _stop_dnsmasq(dev):
     """Stops the dnsmasq instance for a given network."""
-    pid = _dnsmasq_pid_for(network)
+    pid = _dnsmasq_pid_for(dev)
 
     if pid:
         try:
@@ -733,49 +661,49 @@ def _stop_dnsmasq(network):
             LOG.debug(_('Killing dnsmasq threw %s'), exc)
 
 
-def _dhcp_file(bridge, kind):
-    """Return path to a pid, leases or conf file for a bridge."""
+def _dhcp_file(dev, kind):
+    """Return path to a pid, leases or conf file for a bridge/device."""
     if not os.path.exists(FLAGS.networks_path):
         os.makedirs(FLAGS.networks_path)
     return os.path.abspath('%s/nova-%s.%s' % (FLAGS.networks_path,
-                                              bridge,
+                                              dev,
                                               kind))
 
 
-def _ra_file(bridge, kind):
-    """Return path to a pid or conf file for a bridge."""
+def _ra_file(dev, kind):
+    """Return path to a pid or conf file for a bridge/device."""
 
     if not os.path.exists(FLAGS.networks_path):
         os.makedirs(FLAGS.networks_path)
     return os.path.abspath('%s/nova-ra-%s.%s' % (FLAGS.networks_path,
-                                              bridge,
+                                              dev,
                                               kind))
 
 
-def _dnsmasq_pid_for(bridge):
-    """Returns the pid for prior dnsmasq instance for a bridge.
+def _dnsmasq_pid_for(dev):
+    """Returns the pid for prior dnsmasq instance for a bridge/device.
 
     Returns None if no pid file exists.
 
     If machine has rebooted pid might be incorrect (caller should check).
 
     """
-    pid_file = _dhcp_file(bridge, 'pid')
+    pid_file = _dhcp_file(dev, 'pid')
 
     if os.path.exists(pid_file):
         with open(pid_file, 'r') as f:
             return int(f.read())
 
 
-def _ra_pid_for(bridge):
-    """Returns the pid for prior radvd instance for a bridge.
+def _ra_pid_for(dev):
+    """Returns the pid for prior radvd instance for a bridge/device.
 
     Returns None if no pid file exists.
 
     If machine has rebooted pid might be incorrect (caller should check).
 
     """
-    pid_file = _ra_file(bridge, 'pid')
+    pid_file = _ra_file(dev, 'pid')
 
     if os.path.exists(pid_file):
         with open(pid_file, 'r') as f:
@@ -790,4 +718,180 @@ def _ip_bridge_cmd(action, params, device):
     return cmd
 
 
+# Similar to compute virt layers, the Linux network node
+# code uses a flexible driver model to support different ways
+# of creating ethernet interfaces and attaching them to the network.
+# In the case of a network host, these interfaces
+# act as gateway/dhcp/vpn/etc. endpoints not VM interfaces.
+
+
+def plug(network, mac_address):
+    return interface_driver.plug(network, mac_address)
+
+
+def unplug(network):
+    return interface_driver.unplug(network)
+
+
+class LinuxNetInterfaceDriver(object):
+    """Abstract class that defines generic network host API"""
+    """ for for all Linux interface drivers."""
+
+    def plug(self, network, mac_address):
+        """Create Linux device, return device name"""
+        raise NotImplementedError()
+
+    def unplug(self, network):
+        """Destory Linux device, return device name"""
+        raise NotImplementedError()
+
+
+# plugs interfaces using Linux Bridge
+class LinuxBridgeInterfaceDriver(LinuxNetInterfaceDriver):
+
+    def plug(self, network, mac_address):
+        if network.get('vlan', None) is not None:
+            LinuxBridgeInterfaceDriver.ensure_vlan_bridge(
+                           network['vlan'],
+                           network['bridge'],
+                           network['bridge_interface'],
+                           network,
+                           mac_address)
+        else:
+            LinuxBridgeInterfaceDriver.ensure_bridge(
+                          network['bridge'],
+                          network['bridge_interface'],
+                          network)
+
+        return network['bridge']
+
+    def unplug(self, network):
+        return network['bridge']
+
+    @classmethod
+    def ensure_vlan_bridge(_self, vlan_num, bridge, bridge_interface,
+                                            net_attrs=None, mac_address=None):
+        """Create a vlan and bridge unless they already exist."""
+        interface = LinuxBridgeInterfaceDriver.ensure_vlan(vlan_num,
+                                               bridge_interface, mac_address)
+        LinuxBridgeInterfaceDriver.ensure_bridge(bridge, interface, net_attrs)
+        return interface
+
+    @classmethod
+    @utils.synchronized('ensure_vlan', external=True)
+    def ensure_vlan(_self, vlan_num, bridge_interface, mac_address=None):
+        """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('vconfig', 'set_name_type',
+                     'VLAN_PLUS_VID_NO_PAD', run_as_root=True)
+            _execute('vconfig', 'add', bridge_interface,
+                        vlan_num, run_as_root=True)
+            # (danwent) the bridge will inherit this address, so we want to
+            # make sure it is the value set from the NetworkManager
+            if mac_address:
+                _execute('ip', 'link', 'set', interface, "address",
+                            mac_address, run_as_root=True)
+            _execute('ip', 'link', 'set', interface, 'up', run_as_root=True)
+        return interface
+
+    @classmethod
+    @utils.synchronized('ensure_bridge', external=True)
+    def ensure_bridge(_self, 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 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 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('brctl', 'addbr', bridge, run_as_root=True)
+            _execute('brctl', 'setfd', bridge, 0, run_as_root=True)
+            # _execute('brctl setageing %s 10' % bridge, run_as_root=True)
+            _execute('brctl', 'stp', bridge, 'off', run_as_root=True)
+            # (danwent) bridge device MAC address can't be set directly.
+            # instead it inherits the MAC address of the first device on the
+            # bridge, which will either be the vlan interface, or a
+            # physical NIC.
+            _execute('ip', 'link', 'set', bridge, 'up', run_as_root=True)
+
+        if interface:
+            out, err = _execute('brctl', 'addif', bridge, interface,
+                            check_exit_code=False, run_as_root=True)
+
+            # 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('route', '-n', run_as_root=True)
+            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]
+                    _execute('route', 'del', 'default', 'gw', gateway,
+                             'dev', interface, check_exit_code=False,
+                             run_as_root=True)
+            out, err = _execute('ip', 'addr', 'show', 'dev', interface,
+                                'scope', 'global', run_as_root=True)
+            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]),
+                                run_as_root=True)
+                    _execute(*_ip_bridge_cmd('add', params, bridge),
+                                run_as_root=True)
+            if gateway:
+                _execute('route', 'add', 'default', 'gw', gateway,
+                            run_as_root=True)
+
+            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)
+
+        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)
+
+
+# plugs interfaces using Open vSwitch
+class LinuxOVSInterfaceDriver(LinuxNetInterfaceDriver):
+
+    def plug(self, network, mac_address):
+        dev = "gw-" + str(network['id'])
+        if not _device_exists(dev):
+            bridge = FLAGS.linuxnet_ovs_integration_bridge
+            _execute('ovs-vsctl',
+                        '--', '--may-exist', 'add-port', bridge, dev,
+                        '--', 'set', 'Interface', dev, "type=internal",
+                        '--', 'set', 'Interface', dev,
+                                "external-ids:iface-id=nova-%s" % dev,
+                        '--', 'set', 'Interface', dev,
+                                "external-ids:iface-status=active",
+                        '--', 'set', 'Interface', dev,
+                                "external-ids:attached-mac=%s" % mac_address,
+                        run_as_root=True)
+            _execute('ip', 'link', 'set', dev, "address", mac_address,
+                        run_as_root=True)
+            _execute('ip', 'link', 'set', dev, 'up', run_as_root=True)
+
+        return dev
+
+    def unplug(self, network):
+        dev = "gw-" + str(network['id'])
+        return dev
+
 iptables_manager = IptablesManager()
+interface_driver = utils.import_object(FLAGS.linuxnet_interface_driver)
diff --git a/nova/network/manager.py b/nova/network/manager.py
index b1b3f8ba2..921c27e45 100644
--- a/nova/network/manager.py
+++ b/nova/network/manager.py
@@ -45,6 +45,7 @@ topologies.  All of the network commands are issued to a subclass of
 """
 
 import datetime
+import itertools
 import math
 import netaddr
 import socket
@@ -499,6 +500,7 @@ class NetworkManager(manager.SchedulerDependentManager):
                 'dhcp_server': dhcp_server,
                 'broadcast': network['broadcast'],
                 'mac': vif['address'],
+                'vif_uuid': vif['uuid'],
                 'rxtx_cap': flavor['rxtx_cap'],
                 'dns': [],
                 'ips': [ip_dict(ip) for ip in network_IPs],
@@ -523,7 +525,8 @@ class NetworkManager(manager.SchedulerDependentManager):
         for network in networks:
             vif = {'address': self.generate_mac_address(),
                    'instance_id': instance_id,
-                   'network_id': network['id']}
+                   'network_id': network['id'],
+                   'uuid': str(utils.gen_uuid())}
             # try FLAG times to create a vif record with a unique mac_address
             for i in range(FLAGS.create_unique_mac_address_attempts):
                 try:
@@ -537,7 +540,7 @@ class NetworkManager(manager.SchedulerDependentManager):
                 raise exception.VirtualInterfaceMacAddressException()
 
     def generate_mac_address(self):
-        """Generate a mac address for a vif on an instance."""
+        """Generate an Ethernet MAC address."""
         mac = [0x02, 0x16, 0x3e,
                random.randint(0x00, 0x7f),
                random.randint(0x00, 0xff),
@@ -632,121 +635,112 @@ class NetworkManager(manager.SchedulerDependentManager):
                 network_ref = self.db.fixed_ip_get_network(context, address)
                 self._setup_network(context, network_ref)
 
-    def _validate_cidrs(self, context, cidr, num_networks, network_size):
-        significant_bits = 32 - int(math.log(network_size, 2))
-        req_net = netaddr.IPNetwork(cidr)
-        req_net_ip = str(req_net.ip)
-        req_size = network_size * num_networks
-        if req_size > req_net.size:
-            msg = _("network_size * num_networks exceeds cidr size")
-            raise ValueError(msg)
-        adjusted_cidr_str = req_net_ip + '/' + str(significant_bits)
-        adjusted_cidr = netaddr.IPNetwork(adjusted_cidr_str)
-        try:
-            used_nets = self.db.network_get_all(context)
-        except exception.NoNetworksFound:
-            used_nets = []
-        used_cidrs = [netaddr.IPNetwork(net['cidr']) for net in used_nets]
-        if adjusted_cidr in used_cidrs:
-            raise ValueError(_("cidr already in use"))
-        for adjusted_cidr_supernet in adjusted_cidr.supernet():
-            if adjusted_cidr_supernet in used_cidrs:
-                msg = _("requested cidr (%s) conflicts with existing supernet")
-                raise ValueError(msg % str(adjusted_cidr))
-        # watch for smaller subnets conflicting
-        used_supernets = []
-        for used_cidr in used_cidrs:
-            if not used_cidr:
-                continue
-            if used_cidr.size < network_size:
-                for ucsupernet in used_cidr.supernet():
-                    if ucsupernet.size == network_size:
-                        used_supernets.append(ucsupernet)
-        all_req_nets = []
-        if num_networks == 1:
-            if adjusted_cidr in used_supernets:
-                msg = _("requested cidr (%s) conflicts with existing smaller"
-                        " cidr")
-                raise ValueError(msg % str(adjusted_cidr))
-            else:
-                all_req_nets.append(adjusted_cidr)
-        elif num_networks >= 2:
-            # split supernet into subnets
-            next_cidr = adjusted_cidr
-            for index in range(num_networks):
-                if next_cidr.first > req_net.last:
-                    msg = _("Not enough subnets avail to satisfy requested "
-                            "num_net works - some subnets in requested range"
-                            " already in use")
-                    raise ValueError(msg)
-                while True:
-                    used_values = used_cidrs + used_supernets
-                    if next_cidr in used_values:
-                        next_cidr = next_cidr.next()
-                    else:
-                        all_req_nets.append(next_cidr)
-                        next_cidr = next_cidr.next()
-                        break
-        all_req_nets = sorted(list(set(all_req_nets)))
-        return all_req_nets
-
     def create_networks(self, context, label, cidr, multi_host, num_networks,
                         network_size, cidr_v6, gateway_v6, bridge,
                         bridge_interface, dns1=None, dns2=None, **kwargs):
         """Create networks based on parameters."""
+        # NOTE(jkoelker): these are dummy values to make sure iter works
+        fixed_net_v4 = netaddr.IPNetwork('0/32')
+        fixed_net_v6 = netaddr.IPNetwork('::0/128')
+        subnets_v4 = []
+        subnets_v6 = []
+
+        subnet_bits = int(math.ceil(math.log(network_size, 2)))
+
         if cidr_v6:
             fixed_net_v6 = netaddr.IPNetwork(cidr_v6)
-            significant_bits_v6 = 64
-            network_size_v6 = 1 << 64
+            prefixlen_v6 = 128 - subnet_bits
+            subnets_v6 = fixed_net_v6.subnet(prefixlen_v6, count=num_networks)
 
         if cidr:
-            req_cidrs = self._validate_cidrs(context, cidr, num_networks,
-                                             network_size)
-
-        for index in range(num_networks):
+            fixed_net_v4 = netaddr.IPNetwork(cidr)
+            prefixlen_v4 = 32 - subnet_bits
+            subnets_v4 = list(fixed_net_v4.subnet(prefixlen_v4,
+                                                  count=num_networks))
+
+            # NOTE(jkoelker): This replaces the _validate_cidrs call and
+            #                 prevents looping multiple times
+            try:
+                nets = self.db.network_get_all(context)
+            except exception.NoNetworksFound:
+                nets = []
+            used_subnets = [netaddr.IPNetwork(net['cidr']) for net in nets]
+
+            def find_next(subnet):
+                next_subnet = subnet.next()
+                while next_subnet in subnets_v4:
+                    next_subnet = next_subnet.next()
+                if next_subnet in fixed_net_v4:
+                    return next_subnet
+
+            for subnet in list(subnets_v4):
+                if subnet in used_subnets:
+                    next_subnet = find_next(subnet)
+                    if next_subnet:
+                        subnets_v4.remove(subnet)
+                        subnets_v4.append(next_subnet)
+                        subnet = next_subnet
+                    else:
+                        raise ValueError(_('cidr already in use'))
+                for used_subnet in used_subnets:
+                    if subnet in used_subnet:
+                        msg = _('requested cidr (%(cidr)s) conflicts with '
+                                'existing supernet (%(super)s)')
+                        raise ValueError(msg % {'cidr': subnet,
+                                                'super': used_subnet})
+                    if used_subnet in subnet:
+                        next_subnet = find_next(subnet)
+                        if next_subnet:
+                            subnets_v4.remove(subnet)
+                            subnets_v4.append(next_subnet)
+                            subnet = next_subnet
+                        else:
+                            msg = _('requested cidr (%(cidr)s) conflicts '
+                                    'with existing smaller cidr '
+                                    '(%(smaller)s)')
+                            raise ValueError(msg % {'cidr': subnet,
+                                                    'smaller': used_subnet})
+
+        networks = []
+        subnets = itertools.izip_longest(subnets_v4, subnets_v6)
+        for index, (subnet_v4, subnet_v6) in enumerate(subnets):
             net = {}
             net['bridge'] = bridge
             net['bridge_interface'] = bridge_interface
+            net['multi_host'] = multi_host
+
             net['dns1'] = dns1
             net['dns2'] = dns2
 
-            if cidr:
-                project_net = req_cidrs[index]
-                net['cidr'] = str(project_net)
-                net['multi_host'] = multi_host
-                net['netmask'] = str(project_net.netmask)
-                net['gateway'] = str(project_net[1])
-                net['broadcast'] = str(project_net.broadcast)
-                net['dhcp_start'] = str(project_net[2])
-
             if num_networks > 1:
                 net['label'] = '%s_%d' % (label, index)
             else:
                 net['label'] = label
 
-            if cidr_v6:
-                start_v6 = index * network_size_v6
-                cidr_v6 = '%s/%s' % (fixed_net_v6[start_v6],
-                                     significant_bits_v6)
-                net['cidr_v6'] = cidr_v6
-
-                project_net_v6 = netaddr.IPNetwork(cidr_v6)
+            if cidr and subnet_v4:
+                net['cidr'] = str(subnet_v4)
+                net['netmask'] = str(subnet_v4.netmask)
+                net['gateway'] = str(subnet_v4[1])
+                net['broadcast'] = str(subnet_v4.broadcast)
+                net['dhcp_start'] = str(subnet_v4[2])
 
+            if cidr_v6 and subnet_v6:
+                net['cidr_v6'] = str(subnet_v6)
                 if gateway_v6:
                     # use a pre-defined gateway if one is provided
                     net['gateway_v6'] = str(gateway_v6)
                 else:
-                    net['gateway_v6'] = str(project_net_v6[1])
+                    net['gateway_v6'] = str(subnet_v6[1])
 
-                net['netmask_v6'] = str(project_net_v6._prefixlen)
+                net['netmask_v6'] = str(subnet_v6._prefixlen)
 
             if kwargs.get('vpn', False):
                 # this bit here is for vlan-manager
                 del net['dns1']
                 del net['dns2']
                 vlan = kwargs['vlan_start'] + index
-                net['vpn_private_address'] = str(project_net[2])
-                net['dhcp_start'] = str(project_net[3])
+                net['vpn_private_address'] = str(subnet_v4[2])
+                net['dhcp_start'] = str(subnet_v4[3])
                 net['vlan'] = vlan
                 net['bridge'] = 'br%s' % vlan
 
@@ -759,9 +753,12 @@ class NetworkManager(manager.SchedulerDependentManager):
 
             if not network:
                 raise ValueError(_('Network already exists!'))
+            else:
+                networks.append(network)
 
-            if network and cidr:
+            if network and cidr and subnet_v4:
                 self._create_fixed_ips(context, network['id'])
+        return networks
 
     @property
     def _bottom_reserved_ips(self):  # pylint: disable=R0201
@@ -877,14 +874,16 @@ class FlatDHCPManager(FloatingIP, RPCAllocateFixedIP, NetworkManager):
     def _setup_network(self, context, network_ref):
         """Sets up network on this host."""
         network_ref['dhcp_server'] = self._get_dhcp_ip(context, network_ref)
-        self.driver.ensure_bridge(network_ref['bridge'],
-                                  network_ref['bridge_interface'],
-                                  network_ref)
+
+        mac_address = self.generate_mac_address()
+        dev = self.driver.plug(network_ref, mac_address)
+        self.driver.initialize_gateway_device(dev, network_ref)
+
         if not FLAGS.fake_network:
-            self.driver.update_dhcp(context, network_ref)
+            self.driver.update_dhcp(context, dev, network_ref)
             if(FLAGS.use_ipv6):
-                self.driver.update_ra(context, network_ref)
-                gateway = utils.get_my_linklocal(network_ref['bridge'])
+                self.driver.update_ra(context, dev, network_ref)
+                gateway = utils.get_my_linklocal(dev)
                 self.db.network_update(context, network_ref['id'],
                                        {'gateway_v6': gateway})
 
@@ -978,23 +977,23 @@ class VlanManager(RPCAllocateFixedIP, FloatingIP, NetworkManager):
         else:
             address = network_ref['vpn_public_address']
         network_ref['dhcp_server'] = self._get_dhcp_ip(context, network_ref)
-        self.driver.ensure_vlan_bridge(network_ref['vlan'],
-                                       network_ref['bridge'],
-                                       network_ref['bridge_interface'],
-                                       network_ref)
+
+        mac_address = self.generate_mac_address()
+        dev = self.driver.plug(network_ref, mac_address)
+        self.driver.initialize_gateway_device(dev, network_ref)
 
         # NOTE(vish): only ensure this forward if the address hasn't been set
         #             manually.
         if address == FLAGS.vpn_ip and hasattr(self.driver,
-                                               "ensure_vlan_forward"):
-            self.driver.ensure_vlan_forward(FLAGS.vpn_ip,
+                                               "ensure_vpn_forward"):
+            self.driver.ensure_vpn_forward(FLAGS.vpn_ip,
                                             network_ref['vpn_public_port'],
                                             network_ref['vpn_private_address'])
         if not FLAGS.fake_network:
-            self.driver.update_dhcp(context, network_ref)
+            self.driver.update_dhcp(context, dev, network_ref)
             if(FLAGS.use_ipv6):
-                self.driver.update_ra(context, network_ref)
-                gateway = utils.get_my_linklocal(network_ref['bridge'])
+                self.driver.update_ra(context, dev, network_ref)
+                gateway = utils.get_my_linklocal(dev)
                 self.db.network_update(context, network_ref['id'],
                                        {'gateway_v6': gateway})
 
diff --git a/nova/quota.py b/nova/quota.py
index 58766e846..48e598659 100644
--- a/nova/quota.py
+++ b/nova/quota.py
@@ -164,5 +164,5 @@ def allowed_injected_file_path_bytes(context):
 
 
 class QuotaError(exception.ApiError):
-    """Quota Exceeeded."""
+    """Quota Exceeded."""
     pass
diff --git a/nova/scheduler/__init__.py b/nova/scheduler/__init__.py
index 8359a7aeb..25078f015 100644
--- a/nova/scheduler/__init__.py
+++ b/nova/scheduler/__init__.py
@@ -21,5 +21,7 @@
 .. automodule:: nova.scheduler
    :platform: Unix
    :synopsis: Module that picks a compute node to run a VM instance.
+.. moduleauthor:: Sandy Walsh <sandy.walsh@rackspace.com>
+.. moduleauthor:: Ed Leafe <ed@leafe.com>
 .. moduleauthor:: Chris Behrens <cbehrens@codestud.com>
 """
diff --git a/nova/scheduler/abstract_scheduler.py b/nova/scheduler/abstract_scheduler.py
index eb924732a..e8c343a4b 100644
--- a/nova/scheduler/abstract_scheduler.py
+++ b/nova/scheduler/abstract_scheduler.py
@@ -14,10 +14,10 @@
 #    under the License.
 
 """
-The AbsractScheduler is a base class Scheduler for creating instances
-across zones. There are two expansion points to this class for:
-1. Assigning Weights to hosts for requested instances
-2. Filtering Hosts based on required instance capabilities
+The AbsractScheduler is an abstract class Scheduler for creating instances
+locally or across zones. Two methods should be overridden in order to
+customize the behavior: filter_hosts() and weigh_hosts(). The default
+behavior is to simply select all hosts and weight them the same.
 """
 
 import operator
@@ -45,44 +45,44 @@ LOG = logging.getLogger('nova.scheduler.abstract_scheduler')
 
 class InvalidBlob(exception.NovaException):
     message = _("Ill-formed or incorrectly routed 'blob' data sent "
-                "to instance create request.")
+            "to instance create request.")
 
 
 class AbstractScheduler(driver.Scheduler):
     """Base class for creating Schedulers that can work across any nova
     deployment, from simple designs to multiply-nested zones.
     """
-
     def _call_zone_method(self, context, method, specs, zones):
         """Call novaclient zone method. Broken out for testing."""
         return api.call_zone_method(context, method, specs=specs, zones=zones)
 
     def _provision_resource_locally(self, context, build_plan_item,
-                                    request_spec, kwargs):
+            request_spec, kwargs):
         """Create the requested resource in this Zone."""
         host = build_plan_item['hostname']
         base_options = request_spec['instance_properties']
         image = request_spec['image']
+        instance_type = request_spec.get('instance_type')
 
         # TODO(sandy): I guess someone needs to add block_device_mapping
         # support at some point? Also, OS API has no concept of security
         # groups.
         instance = compute_api.API().create_db_entry_for_new_instance(context,
-            image, base_options, None, [])
+                instance_type, image, base_options, None, [])
 
         instance_id = instance['id']
         kwargs['instance_id'] = instance_id
 
-        rpc.cast(context,
-                 db.queue_get_for(context, "compute", host),
-                 {"method": "run_instance",
-                  "args": kwargs})
+        queue = db.queue_get_for(context, "compute", host)
+        params = {"method": "run_instance", "args": kwargs}
+        rpc.cast(context, queue, params)
         LOG.debug(_("Provisioning locally via compute node %(host)s")
-                            % locals())
+                % locals())
 
     def _decrypt_blob(self, blob):
         """Returns the decrypted blob or None if invalid. Broken out
-        for testing."""
+        for testing.
+        """
         decryptor = crypto.decryptor(FLAGS.build_plan_encryption_key)
         try:
             json_entry = decryptor(blob)
@@ -92,15 +92,15 @@ class AbstractScheduler(driver.Scheduler):
         return None
 
     def _ask_child_zone_to_create_instance(self, context, zone_info,
-                                           request_spec, kwargs):
+            request_spec, kwargs):
         """Once we have determined that the request should go to one
         of our children, we need to fabricate a new POST /servers/
         call with the same parameters that were passed into us.
 
         Note that we have to reverse engineer from our args to get back the
         image, flavor, ipgroup, etc. since the original call could have
-        come in from EC2 (which doesn't use these things)."""
-
+        come in from EC2 (which doesn't use these things).
+        """
         instance_type = request_spec['instance_type']
         instance_properties = request_spec['instance_properties']
 
@@ -109,30 +109,26 @@ class AbstractScheduler(driver.Scheduler):
         meta = instance_properties['metadata']
         flavor_id = instance_type['flavorid']
         reservation_id = instance_properties['reservation_id']
-
         files = kwargs['injected_files']
         ipgroup = None  # Not supported in OS API ... yet
-
         child_zone = zone_info['child_zone']
         child_blob = zone_info['child_blob']
         zone = db.zone_get(context, child_zone)
         url = zone.api_url
         LOG.debug(_("Forwarding instance create call to child zone %(url)s"
-                    ". ReservationID=%(reservation_id)s")
-                    % locals())
+                ". ReservationID=%(reservation_id)s") % locals())
         nova = None
         try:
             nova = novaclient.Client(zone.username, zone.password, None, url)
             nova.authenticate()
         except novaclient_exceptions.BadRequest, e:
             raise exception.NotAuthorized(_("Bad credentials attempting "
-                            "to talk to zone at %(url)s.") % locals())
-
+                    "to talk to zone at %(url)s.") % locals())
         nova.servers.create(name, image_ref, flavor_id, ipgroup, meta, files,
-                            child_blob, reservation_id=reservation_id)
+                child_blob, reservation_id=reservation_id)
 
     def _provision_resource_from_blob(self, context, build_plan_item,
-                                      instance_id, request_spec, kwargs):
+            instance_id, request_spec, kwargs):
         """Create the requested resource locally or in a child zone
            based on what is stored in the zone blob info.
 
@@ -145,8 +141,8 @@ class AbstractScheduler(driver.Scheduler):
            means we gathered the info from one of our children.
            It's possible that, when we decrypt the 'blob' field, it
            contains "child_blob" data. In which case we forward the
-           request."""
-
+           request.
+           """
         host_info = None
         if "blob" in build_plan_item:
             # Request was passed in from above. Is it for us?
@@ -161,21 +157,20 @@ class AbstractScheduler(driver.Scheduler):
         # Valid data ... is it for us?
         if 'child_zone' in host_info and 'child_blob' in host_info:
             self._ask_child_zone_to_create_instance(context, host_info,
-                                                    request_spec, kwargs)
+                    request_spec, kwargs)
         else:
             self._provision_resource_locally(context, host_info, request_spec,
-                                             kwargs)
+                    kwargs)
 
     def _provision_resource(self, context, build_plan_item, instance_id,
-                            request_spec, kwargs):
+            request_spec, kwargs):
         """Create the requested resource in this Zone or a child zone."""
         if "hostname" in build_plan_item:
             self._provision_resource_locally(context, build_plan_item,
-                                             request_spec, kwargs)
+                    request_spec, kwargs)
             return
-
         self._provision_resource_from_blob(context, build_plan_item,
-                                           instance_id, request_spec, kwargs)
+                instance_id, request_spec, kwargs)
 
     def _adjust_child_weights(self, child_results, zones):
         """Apply the Scale and Offset values from the Zone definition
@@ -185,13 +180,11 @@ class AbstractScheduler(driver.Scheduler):
         for zone_id, result in child_results:
             if not result:
                 continue
-
             assert isinstance(zone_id, int)
 
             for zone_rec in zones:
                 if zone_rec['id'] != zone_id:
                     continue
-
                 for item in result:
                     try:
                         offset = zone_rec['weight_offset']
@@ -202,10 +195,10 @@ class AbstractScheduler(driver.Scheduler):
                         item['raw_weight'] = raw_weight
                     except KeyError:
                         LOG.exception(_("Bad child zone scaling values "
-                                        "for Zone: %(zone_id)s") % locals())
+                                "for Zone: %(zone_id)s") % locals())
 
     def schedule_run_instance(self, context, instance_id, request_spec,
-                              *args, **kwargs):
+            *args, **kwargs):
         """This method is called from nova.compute.api to provision
         an instance. However we need to look at the parameters being
         passed in to see if this is a request to:
@@ -214,13 +207,11 @@ class AbstractScheduler(driver.Scheduler):
            to simply create the instance (either in this zone or
            a child zone).
         """
-
         # TODO(sandy): We'll have to look for richer specs at some point.
-
         blob = request_spec.get('blob')
         if blob:
             self._provision_resource(context, request_spec, instance_id,
-                                    request_spec, kwargs)
+                    request_spec, kwargs)
             return None
 
         num_instances = request_spec.get('num_instances', 1)
@@ -235,10 +226,9 @@ class AbstractScheduler(driver.Scheduler):
         for num in xrange(num_instances):
             if not build_plan:
                 break
-
             build_plan_item = build_plan.pop(0)
             self._provision_resource(context, build_plan_item, instance_id,
-                                     request_spec, kwargs)
+                    request_spec, kwargs)
 
         # Returning None short-circuits the routing to Compute (since
         # we've already done it here)
@@ -251,58 +241,44 @@ class AbstractScheduler(driver.Scheduler):
         anything about the children.
         """
         return self._schedule(context, "compute", request_spec,
-                              *args, **kwargs)
+                *args, **kwargs)
 
-    # TODO(sandy): We're only focused on compute instances right now,
-    # so we don't implement the default "schedule()" method required
-    # of Schedulers.
     def schedule(self, context, topic, request_spec, *args, **kwargs):
         """The schedule() contract requires we return the one
         best-suited host for this request.
         """
-        raise driver.NoValidHost(_('No hosts were available'))
+        # TODO(sandy): We're only focused on compute instances right now,
+        # so we don't implement the default "schedule()" method required
+        # of Schedulers.
+        msg = _("No host selection for %s defined." % topic)
+        raise driver.NoValidHost(msg)
 
     def _schedule(self, context, topic, request_spec, *args, **kwargs):
         """Returns a list of hosts that meet the required specs,
         ordered by their fitness.
         """
-
         if topic != "compute":
-            raise NotImplementedError(_("Scheduler only understands"
-                                        " Compute nodes (for now)"))
-
-        num_instances = request_spec.get('num_instances', 1)
-        instance_type = request_spec['instance_type']
-
-        weighted = []
-        host_list = None
-
-        for i in xrange(num_instances):
-            # Filter local hosts based on requirements ...
-            #
-            # The first pass through here will pass 'None' as the
-            # host_list.. which tells the filter to build the full
-            # list of hosts.
-            # On a 2nd pass, the filter can modify the host_list with
-            # any updates it needs to make based on resources that
-            # may have been consumed from a previous build..
-            host_list = self.filter_hosts(topic, request_spec, host_list)
-            if not host_list:
-                LOG.warn(_("Filter returned no hosts after processing "
-                        "%(i)d of %(num_instances)d instances") % locals())
-                break
-
-            # then weigh the selected hosts.
-            # weighted = [{weight=weight, hostname=hostname,
-            #              capabilities=capabs}, ...]
-            weights = self.weigh_hosts(topic, request_spec, host_list)
-            weights.sort(key=operator.itemgetter('weight'))
-            best_weight = weights[0]
-            weighted.append(best_weight)
-            self.consume_resources(topic, best_weight['capabilities'],
-                    instance_type)
-
-        # Next, tack on the best weights from the child zones ...
+            msg = _("Scheduler only understands Compute nodes (for now)")
+            raise NotImplementedError(msg)
+
+        # Get all available hosts.
+        all_hosts = self.zone_manager.service_states.iteritems()
+        unfiltered_hosts = [(host, services[topic])
+                for host, services in all_hosts
+                if topic in services]
+
+        # Filter local hosts based on requirements ...
+        filtered_hosts = self.filter_hosts(topic, request_spec,
+                unfiltered_hosts)
+        if not filtered_hosts:
+            LOG.warn(_("No hosts available"))
+            return []
+
+        # weigh the selected hosts.
+        # weighted_hosts = [{weight=weight, hostname=hostname,
+        #         capabilities=capabs}, ...]
+        weighted_hosts = self.weigh_hosts(topic, request_spec, filtered_hosts)
+        # Next, tack on the host weights from the child zones
         json_spec = json.dumps(request_spec)
         all_zones = db.zone_get_all(context)
         child_results = self._call_zone_method(context, "select",
@@ -314,90 +290,32 @@ class AbstractScheduler(driver.Scheduler):
                 # it later if needed. This implicitly builds a zone
                 # path structure.
                 host_dict = {"weight": weighting["weight"],
-                             "child_zone": child_zone,
-                             "child_blob": weighting["blob"]}
-                weighted.append(host_dict)
-
-        weighted.sort(key=operator.itemgetter('weight'))
-        return weighted
-
-    def compute_filter(self, hostname, capabilities, request_spec):
-        """Return whether or not we can schedule to this compute node.
-        Derived classes should override this and return True if the host
-        is acceptable for scheduling.
+                        "child_zone": child_zone,
+                        "child_blob": weighting["blob"]}
+                weighted_hosts.append(host_dict)
+        weighted_hosts.sort(key=operator.itemgetter('weight'))
+        return weighted_hosts
+
+    def filter_hosts(self, topic, request_spec, host_list):
+        """Filter the full host list returned from the ZoneManager. By default,
+        this method only applies the basic_ram_filter(), meaning all hosts
+        with at least enough RAM for the requested instance are returned.
+
+        Override in subclasses to provide greater selectivity.
         """
-        instance_type = request_spec['instance_type']
-        requested_mem = instance_type['memory_mb'] * 1024 * 1024
-        return capabilities['host_memory_free'] >= requested_mem
-
-    def hold_filter_hosts(self, topic, request_spec, hosts=None):
-        """Filter the full host list (from the ZoneManager)"""
-        # NOTE(dabo): The logic used by the current _schedule() method
-        # is incorrect. Since this task is just to refactor the classes,
-        # I'm not fixing the logic now - that will be the next task.
-        # So for now this method is just renamed; afterwards this will
-        # become the filter_hosts() method, and the one below will
-        # be removed.
-        filter_name = request_spec.get('filter', None)
-        # Make sure that the requested filter is legitimate.
-        selected_filter = host_filter.choose_host_filter(filter_name)
-
-        # TODO(sandy): We're only using InstanceType-based specs
-        # currently. Later we'll need to snoop for more detailed
-        # host filter requests.
-        instance_type = request_spec['instance_type']
-        name, query = selected_filter.instance_type_to_filter(instance_type)
-        return selected_filter.filter_hosts(self.zone_manager, query)
-
-    def filter_hosts(self, topic, request_spec, host_list=None):
-        """Return a list of hosts which are acceptable for scheduling.
-        Return value should be a list of (hostname, capability_dict)s.
-        Derived classes may override this, but may find the
-        '<topic>_filter' function more appropriate.
-        """
-        def _default_filter(self, hostname, capabilities, request_spec):
-            """Default filter function if there's no <topic>_filter"""
-            # NOTE(sirp): The default logic is the equivalent to
-            # AllHostsFilter
-            return True
+        def basic_ram_filter(hostname, capabilities, request_spec):
+            """Only return hosts with sufficient available RAM."""
+            instance_type = request_spec['instance_type']
+            requested_mem = instance_type['memory_mb'] * 1024 * 1024
+            return capabilities['host_memory_free'] >= requested_mem
 
-        filter_func = getattr(self, '%s_filter' % topic, _default_filter)
-
-        if host_list is None:
-            first_run = True
-            host_list = self.zone_manager.service_states.iteritems()
-        else:
-            first_run = False
-
-        filtered_hosts = []
-        for host, services in host_list:
-            if first_run:
-                if topic not in services:
-                    continue
-                services = services[topic]
-            if filter_func(host, services, request_spec):
-                filtered_hosts.append((host, services))
-        return filtered_hosts
+        return [(host, services) for host, services in host_list
+                if basic_ram_filter(host, services, request_spec)]
 
     def weigh_hosts(self, topic, request_spec, hosts):
-        """Derived classes may override this to provide more sophisticated
-        scheduling objectives
+        """This version assigns a weight of 1 to all hosts, making selection
+        of any host basically a random event. Override this method in your
+        subclass to add logic to prefer one potential host over another.
         """
-        # NOTE(sirp): The default logic is the same as the NoopCostFunction
         return [dict(weight=1, hostname=hostname, capabilities=capabilities)
                 for hostname, capabilities in hosts]
-
-    def compute_consume(self, capabilities, instance_type):
-        """Consume compute resources for selected host"""
-
-        requested_mem = max(instance_type['memory_mb'], 0) * 1024 * 1024
-        capabilities['host_memory_free'] -= requested_mem
-
-    def consume_resources(self, topic, capabilities, instance_type):
-        """Consume resources for a specific host.  'host' is a tuple
-        of the hostname and the services"""
-
-        consume_func = getattr(self, '%s_consume' % topic, None)
-        if not consume_func:
-            return
-        consume_func(capabilities, instance_type)
diff --git a/nova/scheduler/base_scheduler.py b/nova/scheduler/base_scheduler.py
new file mode 100644
index 000000000..35e5af035
--- /dev/null
+++ b/nova/scheduler/base_scheduler.py
@@ -0,0 +1,59 @@
+# Copyright (c) 2011 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.
+
+"""
+The BaseScheduler is the base class Scheduler for creating instances
+across zones. There are two expansion points to this class for:
+1. Assigning Weights to hosts for requested instances
+2. Filtering Hosts based on required instance capabilities
+"""
+
+from nova import flags
+from nova import log as logging
+
+from nova.scheduler import abstract_scheduler
+from nova.scheduler import host_filter
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.scheduler.base_scheduler')
+
+
+class BaseScheduler(abstract_scheduler.AbstractScheduler):
+    """Base class for creating Schedulers that can work across any nova
+    deployment, from simple designs to multiply-nested zones.
+    """
+    def filter_hosts(self, topic, request_spec, hosts=None):
+        """Filter the full host list (from the ZoneManager)"""
+        filter_name = request_spec.get('filter', None)
+        # Make sure that the requested filter is legitimate.
+        selected_filter = host_filter.choose_host_filter(filter_name)
+
+        # TODO(sandy): We're only using InstanceType-based specs
+        # currently. Later we'll need to snoop for more detailed
+        # host filter requests.
+        instance_type = request_spec.get("instance_type", None)
+        if instance_type is None:
+            # No way to select; return the specified hosts
+            return hosts or []
+        name, query = selected_filter.instance_type_to_filter(instance_type)
+        return selected_filter.filter_hosts(self.zone_manager, query)
+
+    def weigh_hosts(self, topic, request_spec, hosts):
+        """Derived classes may override this to provide more sophisticated
+        scheduling objectives
+        """
+        # NOTE(sirp): The default logic is the same as the NoopCostFunction
+        return [dict(weight=1, hostname=hostname, capabilities=capabilities)
+                for hostname, capabilities in hosts]
diff --git a/nova/scheduler/filters/__init__.py b/nova/scheduler/filters/__init__.py
new file mode 100644
index 000000000..b86fb795f
--- /dev/null
+++ b/nova/scheduler/filters/__init__.py
@@ -0,0 +1,36 @@
+# Copyright (c) 2011 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.
+
+"""
+There are three filters included: AllHosts, InstanceType & JSON.
+
+AllHosts just returns the full, unfiltered list of hosts.
+InstanceType is a hard coded matching mechanism based on flavor criteria.
+JSON is an ad-hoc filter grammar.
+
+Why JSON? The requests for instances may come in through the
+REST interface from a user or a parent Zone.
+Currently InstanceTypes are used for specifing the type of instance desired.
+Specific Nova users have noted a need for a more expressive way of specifying
+instance requirements. Since we don't want to get into building full DSL,
+this filter is a simple form as an example of how this could be done.
+In reality, most consumers will use the more rigid filters such as the
+InstanceType filter.
+"""
+
+from abstract_filter import AbstractHostFilter
+from all_hosts_filter import AllHostsFilter
+from instance_type_filter import InstanceTypeFilter
+from json_filter import JsonFilter
diff --git a/nova/scheduler/filters/abstract_filter.py b/nova/scheduler/filters/abstract_filter.py
new file mode 100644
index 000000000..a1d00d562
--- /dev/null
+++ b/nova/scheduler/filters/abstract_filter.py
@@ -0,0 +1,37 @@
+# Copyright (c) 2011 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.
+
+
+import nova.scheduler
+from nova import flags
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('default_host_filter', 'AllHostsFilter',
+        'Which filter to use for filtering hosts')
+
+
+class AbstractHostFilter(object):
+    """Base class for host filters."""
+    def instance_type_to_filter(self, instance_type):
+        """Convert instance_type into a filter for most common use-case."""
+        raise NotImplementedError()
+
+    def filter_hosts(self, zone_manager, query):
+        """Return a list of hosts that fulfill the filter."""
+        raise NotImplementedError()
+
+    def _full_name(self):
+        """module.classname of the filter."""
+        return "%s.%s" % (self.__module__, self.__class__.__name__)
diff --git a/nova/scheduler/filters/all_hosts_filter.py b/nova/scheduler/filters/all_hosts_filter.py
new file mode 100644
index 000000000..e80d829ca
--- /dev/null
+++ b/nova/scheduler/filters/all_hosts_filter.py
@@ -0,0 +1,32 @@
+# Copyright (c) 2011 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.
+
+
+import nova.scheduler
+from nova.scheduler.filters import abstract_filter
+
+
+class AllHostsFilter(abstract_filter.AbstractHostFilter):
+    """NOP host filter. Returns all hosts in ZoneManager."""
+    def instance_type_to_filter(self, instance_type):
+        """Return anything to prevent base-class from raising
+        exception.
+        """
+        return (self._full_name(), instance_type)
+
+    def filter_hosts(self, zone_manager, query):
+        """Return a list of hosts from ZoneManager list."""
+        return [(host, services)
+               for host, services in zone_manager.service_states.iteritems()]
diff --git a/nova/scheduler/filters/instance_type_filter.py b/nova/scheduler/filters/instance_type_filter.py
new file mode 100644
index 000000000..62b9ee414
--- /dev/null
+++ b/nova/scheduler/filters/instance_type_filter.py
@@ -0,0 +1,87 @@
+# Copyright (c) 2011 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.
+
+
+import nova.scheduler
+from nova.scheduler.filters import abstract_filter
+
+
+class InstanceTypeFilter(abstract_filter.AbstractHostFilter):
+    """HostFilter hard-coded to work with InstanceType records."""
+    def instance_type_to_filter(self, instance_type):
+        """Use instance_type to filter hosts."""
+        return (self._full_name(), instance_type)
+
+    def _satisfies_extra_specs(self, capabilities, instance_type):
+        """Check that the capabilities provided by the compute service
+        satisfy the extra specs associated with the instance type"""
+        if 'extra_specs' not in instance_type:
+            return True
+        # NOTE(lorinh): For now, we are just checking exact matching on the
+        # values. Later on, we want to handle numerical
+        # values so we can represent things like number of GPU cards
+        try:
+            for key, value in instance_type['extra_specs'].iteritems():
+                if capabilities[key] != value:
+                    return False
+        except KeyError:
+            return False
+        return True
+
+    def filter_hosts(self, zone_manager, query):
+        """Return a list of hosts that can create instance_type."""
+        instance_type = query
+        selected_hosts = []
+        for host, services in zone_manager.service_states.iteritems():
+            capabilities = services.get('compute', {})
+            if not capabilities:
+                continue
+            host_ram_mb = capabilities['host_memory_free']
+            disk_bytes = capabilities['disk_available']
+            spec_ram = instance_type['memory_mb']
+            spec_disk = instance_type['local_gb']
+            extra_specs = instance_type['extra_specs']
+
+            if ((host_ram_mb >= spec_ram) and (disk_bytes >= spec_disk) and
+                    self._satisfies_extra_specs(capabilities, instance_type)):
+                selected_hosts.append((host, capabilities))
+        return selected_hosts
+
+
+# host entries (currently) are like:
+#    {'host_name-description': 'Default install of XenServer',
+#    'host_hostname': 'xs-mini',
+#    'host_memory_total': 8244539392,
+#    'host_memory_overhead': 184225792,
+#    'host_memory_free': 3868327936,
+#    'host_memory_free_computed': 3840843776,
+#    'host_other_config': {},
+#    'host_ip_address': '192.168.1.109',
+#    'host_cpu_info': {},
+#    'disk_available': 32954957824,
+#    'disk_total': 50394562560,
+#    'disk_used': 17439604736,
+#    'host_uuid': 'cedb9b39-9388-41df-8891-c5c9a0c0fe5f',
+#    'host_name_label': 'xs-mini'}
+
+# instance_type table has:
+# name = Column(String(255), unique=True)
+# memory_mb = Column(Integer)
+# vcpus = Column(Integer)
+# local_gb = Column(Integer)
+# flavorid = Column(Integer, unique=True)
+# swap = Column(Integer, nullable=False, default=0)
+# rxtx_quota = Column(Integer, nullable=False, default=0)
+# rxtx_cap = Column(Integer, nullable=False, default=0)
diff --git a/nova/scheduler/filters/json_filter.py b/nova/scheduler/filters/json_filter.py
new file mode 100644
index 000000000..caf22f5d5
--- /dev/null
+++ b/nova/scheduler/filters/json_filter.py
@@ -0,0 +1,146 @@
+# Copyright (c) 2011 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.
+
+
+import json
+import operator
+
+import nova.scheduler
+from nova.scheduler.filters import abstract_filter
+
+
+class JsonFilter(abstract_filter.AbstractHostFilter):
+    """Host Filter to allow simple JSON-based grammar for
+    selecting hosts.
+    """
+    def _op_compare(self, args, op):
+        """Returns True if the specified operator can successfully
+        compare the first item in the args with all the rest. Will
+        return False if only one item is in the list.
+        """
+        if len(args) < 2:
+            return False
+        if op is operator.contains:
+            bad = not args[0] in args[1:]
+        else:
+            bad = [arg for arg in args[1:]
+                    if not op(args[0], arg)]
+        return not bool(bad)
+
+    def _equals(self, args):
+        """First term is == all the other terms."""
+        return self._op_compare(args, operator.eq)
+
+    def _less_than(self, args):
+        """First term is < all the other terms."""
+        return self._op_compare(args, operator.lt)
+
+    def _greater_than(self, args):
+        """First term is > all the other terms."""
+        return self._op_compare(args, operator.gt)
+
+    def _in(self, args):
+        """First term is in set of remaining terms"""
+        return self._op_compare(args, operator.contains)
+
+    def _less_than_equal(self, args):
+        """First term is <= all the other terms."""
+        return self._op_compare(args, operator.le)
+
+    def _greater_than_equal(self, args):
+        """First term is >= all the other terms."""
+        return self._op_compare(args, operator.ge)
+
+    def _not(self, args):
+        """Flip each of the arguments."""
+        return [not arg for arg in args]
+
+    def _or(self, args):
+        """True if any arg is True."""
+        return any(args)
+
+    def _and(self, args):
+        """True if all args are True."""
+        return all(args)
+
+    commands = {
+        '=': _equals,
+        '<': _less_than,
+        '>': _greater_than,
+        'in': _in,
+        '<=': _less_than_equal,
+        '>=': _greater_than_equal,
+        'not': _not,
+        'or': _or,
+        'and': _and,
+    }
+
+    def instance_type_to_filter(self, instance_type):
+        """Convert instance_type into JSON filter object."""
+        required_ram = instance_type['memory_mb']
+        required_disk = instance_type['local_gb']
+        query = ['and',
+                ['>=', '$compute.host_memory_free', required_ram],
+                ['>=', '$compute.disk_available', required_disk]]
+        return (self._full_name(), json.dumps(query))
+
+    def _parse_string(self, string, host, services):
+        """Strings prefixed with $ are capability lookups in the
+        form '$service.capability[.subcap*]'.
+        """
+        if not string:
+            return None
+        if not string.startswith("$"):
+            return string
+
+        path = string[1:].split(".")
+        for item in path:
+            services = services.get(item, None)
+            if not services:
+                return None
+        return services
+
+    def _process_filter(self, zone_manager, query, host, services):
+        """Recursively parse the query structure."""
+        if not query:
+            return True
+        cmd = query[0]
+        method = self.commands[cmd]
+        cooked_args = []
+        for arg in query[1:]:
+            if isinstance(arg, list):
+                arg = self._process_filter(zone_manager, arg, host, services)
+            elif isinstance(arg, basestring):
+                arg = self._parse_string(arg, host, services)
+            if arg is not None:
+                cooked_args.append(arg)
+        result = method(self, cooked_args)
+        return result
+
+    def filter_hosts(self, zone_manager, query):
+        """Return a list of hosts that can fulfill the requirements
+        specified in the query.
+        """
+        expanded = json.loads(query)
+        filtered_hosts = []
+        for host, services in zone_manager.service_states.iteritems():
+            result = self._process_filter(zone_manager, expanded, host,
+                    services)
+            if isinstance(result, list):
+                # If any succeeded, include the host
+                result = any(result)
+            if result:
+                filtered_hosts.append((host, services))
+        return filtered_hosts
diff --git a/nova/scheduler/host_filter.py b/nova/scheduler/host_filter.py
index 45a8f40d8..826a99b0a 100644
--- a/nova/scheduler/host_filter.py
+++ b/nova/scheduler/host_filter.py
@@ -20,283 +20,33 @@ either incompatible or insufficient to accept a newly-requested instance
 are removed by Host Filter classes from consideration. Those that pass
 the filter are then passed on for weighting or other process for ordering.
 
-Three filters are included: AllHosts, Flavor & JSON. AllHosts just
-returns the full, unfiltered list of hosts. Flavor is a hard coded
-matching mechanism based on flavor criteria and JSON is an ad-hoc
-filter grammar.
-
-Why JSON? The requests for instances may come in through the
-REST interface from a user or a parent Zone.
-Currently Flavors and/or InstanceTypes are used for
-specifing the type of instance desired. Specific Nova users have
-noted a need for a more expressive way of specifying instances.
-Since we don't want to get into building full DSL this is a simple
-form as an example of how this could be done. In reality, most
-consumers will use the more rigid filters such as FlavorFilter.
+Filters are in the 'filters' directory that is off the 'scheduler'
+directory of nova. Additional filters can be created and added to that
+directory; be sure to add them to the filters/__init__.py file so that
+they are part of the nova.schedulers.filters namespace.
 """
 
-import json
+import types
 
 from nova import exception
 from nova import flags
-from nova import log as logging
-from nova import utils
+import nova.scheduler
 
-LOG = logging.getLogger('nova.scheduler.host_filter')
 
 FLAGS = flags.FLAGS
-flags.DEFINE_string('default_host_filter',
-                    'nova.scheduler.host_filter.AllHostsFilter',
-                    'Which filter to use for filtering hosts.')
-
-
-class HostFilter(object):
-    """Base class for host filters."""
-
-    def instance_type_to_filter(self, instance_type):
-        """Convert instance_type into a filter for most common use-case."""
-        raise NotImplementedError()
-
-    def filter_hosts(self, zone_manager, query):
-        """Return a list of hosts that fulfill the filter."""
-        raise NotImplementedError()
-
-    def _full_name(self):
-        """module.classname of the filter."""
-        return "%s.%s" % (self.__module__, self.__class__.__name__)
-
-
-class AllHostsFilter(HostFilter):
-    """ NOP host filter. Returns all hosts in ZoneManager.
-    This essentially does what the old Scheduler+Chance used
-    to give us.
-    """
-
-    def instance_type_to_filter(self, instance_type):
-        """Return anything to prevent base-class from raising
-        exception."""
-        return (self._full_name(), instance_type)
-
-    def filter_hosts(self, zone_manager, query):
-        """Return a list of hosts from ZoneManager list."""
-        return [(host, services)
-               for host, services in zone_manager.service_states.iteritems()]
-
-
-class InstanceTypeFilter(HostFilter):
-    """HostFilter hard-coded to work with InstanceType records."""
-
-    def instance_type_to_filter(self, instance_type):
-        """Use instance_type to filter hosts."""
-        return (self._full_name(), instance_type)
-
-    def _satisfies_extra_specs(self, capabilities, instance_type):
-        """Check that the capabilities provided by the compute service
-        satisfy the extra specs associated with the instance type"""
-
-        if 'extra_specs' not in instance_type:
-            return True
-
-        # Note(lorinh): For now, we are just checking exact matching on the
-        # values. Later on, we  want to handle numerical
-        # values so we can represent things like number of GPU cards
-
-        try:
-            for key, value in instance_type['extra_specs'].iteritems():
-                if capabilities[key] != value:
-                    return False
-        except KeyError:
-            return False
-
-        return True
-
-    def filter_hosts(self, zone_manager, query):
-        """Return a list of hosts that can create instance_type."""
-        instance_type = query
-        selected_hosts = []
-        for host, services in zone_manager.service_states.iteritems():
-            capabilities = services.get('compute', {})
-            host_ram_mb = capabilities['host_memory_free']
-            disk_bytes = capabilities['disk_available']
-            spec_ram = instance_type['memory_mb']
-            spec_disk = instance_type['local_gb']
-            extra_specs = instance_type['extra_specs']
-
-            if ((host_ram_mb >= spec_ram) and (disk_bytes >= spec_disk) and
-                    self._satisfies_extra_specs(capabilities, instance_type)):
-                selected_hosts.append((host, capabilities))
-        return selected_hosts
-
-#host entries (currently) are like:
-#    {'host_name-description': 'Default install of XenServer',
-#    'host_hostname': 'xs-mini',
-#    'host_memory_total': 8244539392,
-#    'host_memory_overhead': 184225792,
-#    'host_memory_free': 3868327936,
-#    'host_memory_free_computed': 3840843776,
-#    'host_other_config': {},
-#    'host_ip_address': '192.168.1.109',
-#    'host_cpu_info': {},
-#    'disk_available': 32954957824,
-#    'disk_total': 50394562560,
-#    'disk_used': 17439604736,
-#    'host_uuid': 'cedb9b39-9388-41df-8891-c5c9a0c0fe5f',
-#    'host_name_label': 'xs-mini'}
-
-# instance_type table has:
-#name = Column(String(255), unique=True)
-#memory_mb = Column(Integer)
-#vcpus = Column(Integer)
-#local_gb = Column(Integer)
-#flavorid = Column(Integer, unique=True)
-#swap = Column(Integer, nullable=False, default=0)
-#rxtx_quota = Column(Integer, nullable=False, default=0)
-#rxtx_cap = Column(Integer, nullable=False, default=0)
-
-
-class JsonFilter(HostFilter):
-    """Host Filter to allow simple JSON-based grammar for
-    selecting hosts.
-    """
-
-    def _equals(self, args):
-        """First term is == all the other terms."""
-        if len(args) < 2:
-            return False
-        lhs = args[0]
-        for rhs in args[1:]:
-            if lhs != rhs:
-                return False
-        return True
-
-    def _less_than(self, args):
-        """First term is < all the other terms."""
-        if len(args) < 2:
-            return False
-        lhs = args[0]
-        for rhs in args[1:]:
-            if lhs >= rhs:
-                return False
-        return True
-
-    def _greater_than(self, args):
-        """First term is > all the other terms."""
-        if len(args) < 2:
-            return False
-        lhs = args[0]
-        for rhs in args[1:]:
-            if lhs <= rhs:
-                return False
-        return True
-
-    def _in(self, args):
-        """First term is in set of remaining terms"""
-        if len(args) < 2:
-            return False
-        return args[0] in args[1:]
-
-    def _less_than_equal(self, args):
-        """First term is <= all the other terms."""
-        if len(args) < 2:
-            return False
-        lhs = args[0]
-        for rhs in args[1:]:
-            if lhs > rhs:
-                return False
-        return True
-
-    def _greater_than_equal(self, args):
-        """First term is >= all the other terms."""
-        if len(args) < 2:
-            return False
-        lhs = args[0]
-        for rhs in args[1:]:
-            if lhs < rhs:
-                return False
-        return True
-
-    def _not(self, args):
-        """Flip each of the arguments."""
-        if len(args) == 0:
-            return False
-        return [not arg for arg in args]
-
-    def _or(self, args):
-        """True if any arg is True."""
-        return True in args
-
-    def _and(self, args):
-        """True if all args are True."""
-        return False not in args
-
-    commands = {
-        '=': _equals,
-        '<': _less_than,
-        '>': _greater_than,
-        'in': _in,
-        '<=': _less_than_equal,
-        '>=': _greater_than_equal,
-        'not': _not,
-        'or': _or,
-        'and': _and,
-    }
-
-    def instance_type_to_filter(self, instance_type):
-        """Convert instance_type into JSON filter object."""
-        required_ram = instance_type['memory_mb']
-        required_disk = instance_type['local_gb']
-        query = ['and',
-                    ['>=', '$compute.host_memory_free', required_ram],
-                    ['>=', '$compute.disk_available', required_disk]]
-        return (self._full_name(), json.dumps(query))
-
-    def _parse_string(self, string, host, services):
-        """Strings prefixed with $ are capability lookups in the
-        form '$service.capability[.subcap*]'
-        """
-        if not string:
-            return None
-        if string[0] != '$':
-            return string
-
-        path = string[1:].split('.')
-        for item in path:
-            services = services.get(item, None)
-            if not services:
-                return None
-        return services
 
-    def _process_filter(self, zone_manager, query, host, services):
-        """Recursively parse the query structure."""
-        if len(query) == 0:
-            return True
-        cmd = query[0]
-        method = self.commands[cmd]  # Let exception fly.
-        cooked_args = []
-        for arg in query[1:]:
-            if isinstance(arg, list):
-                arg = self._process_filter(zone_manager, arg, host, services)
-            elif isinstance(arg, basestring):
-                arg = self._parse_string(arg, host, services)
-            if arg != None:
-                cooked_args.append(arg)
-        result = method(self, cooked_args)
-        return result
 
-    def filter_hosts(self, zone_manager, query):
-        """Return a list of hosts that can fulfill filter."""
-        expanded = json.loads(query)
-        hosts = []
-        for host, services in zone_manager.service_states.iteritems():
-            r = self._process_filter(zone_manager, expanded, host, services)
-            if isinstance(r, list):
-                r = True in r
-            if r:
-                hosts.append((host, services))
-        return hosts
+def _get_filters():
+    # Imported here to avoid circular imports
+    from nova.scheduler import filters
 
+    def get_itm(nm):
+        return getattr(filters, nm)
 
-FILTERS = [AllHostsFilter, InstanceTypeFilter, JsonFilter]
+    return [get_itm(itm) for itm in dir(filters)
+            if (type(get_itm(itm)) is types.TypeType)
+            and issubclass(get_itm(itm), filters.AbstractHostFilter)
+            and get_itm(itm) is not filters.AbstractHostFilter]
 
 
 def choose_host_filter(filter_name=None):
@@ -307,8 +57,7 @@ def choose_host_filter(filter_name=None):
     """
     if not filter_name:
         filter_name = FLAGS.default_host_filter
-    for filter_class in FILTERS:
-        host_match = "%s.%s" % (filter_class.__module__, filter_class.__name__)
-        if host_match == filter_name:
+    for filter_class in _get_filters():
+        if filter_class.__name__ == filter_name:
             return filter_class()
     raise exception.SchedulerHostFilterNotFound(filter_name=filter_name)
diff --git a/nova/scheduler/least_cost.py b/nova/scheduler/least_cost.py
index a58b11289..903d786cd 100644
--- a/nova/scheduler/least_cost.py
+++ b/nova/scheduler/least_cost.py
@@ -22,14 +22,12 @@ The cost-function and weights are tabulated, and the host with the least cost
 is then selected for provisioning.
 """
 
-# TODO(dabo): This class will be removed in the next merge prop; it remains now
-# because much of the code will be refactored into different classes.
 
 import collections
 
 from nova import flags
 from nova import log as logging
-from nova.scheduler import abstract_scheduler
+from nova.scheduler import base_scheduler
 from nova import utils
 from nova import exception
 
@@ -37,14 +35,16 @@ LOG = logging.getLogger('nova.scheduler.least_cost')
 
 FLAGS = flags.FLAGS
 flags.DEFINE_list('least_cost_scheduler_cost_functions',
-                  ['nova.scheduler.least_cost.noop_cost_fn'],
-                  'Which cost functions the LeastCostScheduler should use.')
+        ['nova.scheduler.least_cost.noop_cost_fn'],
+        'Which cost functions the LeastCostScheduler should use.')
 
 
 # TODO(sirp): Once we have enough of these rules, we can break them out into a
 # cost_functions.py file (perhaps in a least_cost_scheduler directory)
 flags.DEFINE_integer('noop_cost_fn_weight', 1,
-                     'How much weight to give the noop cost function')
+             'How much weight to give the noop cost function')
+flags.DEFINE_integer('compute_fill_first_cost_fn_weight', 1,
+             'How much weight to give the fill-first cost function')
 
 
 def noop_cost_fn(host):
@@ -52,19 +52,64 @@ def noop_cost_fn(host):
     return 1
 
 
-flags.DEFINE_integer('compute_fill_first_cost_fn_weight', 1,
-                     'How much weight to give the fill-first cost function')
-
-
 def compute_fill_first_cost_fn(host):
     """Prefer hosts that have less ram available, filter_hosts will exclude
-    hosts that don't have enough ram"""
-    hostname, caps = host
-    free_mem = caps['host_memory_free']
+    hosts that don't have enough ram.
+    """
+    hostname, service = host
+    caps = service.get("compute", {})
+    free_mem = caps.get("host_memory_free", 0)
     return free_mem
 
 
-class LeastCostScheduler(abstract_scheduler.AbstractScheduler):
+def normalize_list(L):
+    """Normalize an array of numbers such that each element satisfies:
+        0 <= e <= 1
+    """
+    if not L:
+        return L
+    max_ = max(L)
+    if max_ > 0:
+        return [(float(e) / max_) for e in L]
+    return L
+
+
+def weighted_sum(domain, weighted_fns, normalize=True):
+    """Use the weighted-sum method to compute a score for an array of objects.
+    Normalize the results of the objective-functions so that the weights are
+    meaningful regardless of objective-function's range.
+
+    domain - input to be scored
+    weighted_fns - list of weights and functions like:
+        [(weight, objective-functions)]
+
+    Returns an unsorted list of scores. To pair with hosts do:
+        zip(scores, hosts)
+    """
+    # Table of form:
+    #   { domain1: [score1, score2, ..., scoreM]
+    #     ...
+    #     domainN: [score1, score2, ..., scoreM] }
+    score_table = collections.defaultdict(list)
+    for weight, fn in weighted_fns:
+        scores = [fn(elem) for elem in domain]
+        if normalize:
+            norm_scores = normalize_list(scores)
+        else:
+            norm_scores = scores
+        for idx, score in enumerate(norm_scores):
+            weighted_score = score * weight
+            score_table[idx].append(weighted_score)
+
+    # Sum rows in table to compute score for each element in domain
+    domain_scores = []
+    for idx in sorted(score_table):
+        elem_score = sum(score_table[idx])
+        domain_scores.append(elem_score)
+    return domain_scores
+
+
+class LeastCostScheduler(base_scheduler.BaseScheduler):
     def __init__(self, *args, **kwargs):
         self.cost_fns_cache = {}
         super(LeastCostScheduler, self).__init__(*args, **kwargs)
@@ -73,10 +118,8 @@ class LeastCostScheduler(abstract_scheduler.AbstractScheduler):
         """Returns a list of tuples containing weights and cost functions to
         use for weighing hosts
         """
-
         if topic in self.cost_fns_cache:
             return self.cost_fns_cache[topic]
-
         cost_fns = []
         for cost_fn_str in FLAGS.least_cost_scheduler_cost_functions:
             if '.' in cost_fn_str:
@@ -85,7 +128,6 @@ class LeastCostScheduler(abstract_scheduler.AbstractScheduler):
                 short_name = cost_fn_str
                 cost_fn_str = "%s.%s.%s" % (
                         __name__, self.__class__.__name__, short_name)
-
             if not (short_name.startswith('%s_' % topic) or
                     short_name.startswith('noop')):
                 continue
@@ -96,15 +138,14 @@ class LeastCostScheduler(abstract_scheduler.AbstractScheduler):
                 cost_fn = utils.import_class(cost_fn_str)
             except exception.ClassNotFound:
                 raise exception.SchedulerCostFunctionNotFound(
-                    cost_fn_str=cost_fn_str)
+                        cost_fn_str=cost_fn_str)
 
             try:
                 flag_name = "%s_weight" % cost_fn.__name__
                 weight = getattr(FLAGS, flag_name)
             except AttributeError:
                 raise exception.SchedulerWeightFlagNotFound(
-                    flag_name=flag_name)
-
+                        flag_name=flag_name)
             cost_fns.append((weight, cost_fn))
 
         self.cost_fns_cache[topic] = cost_fns
@@ -114,13 +155,13 @@ class LeastCostScheduler(abstract_scheduler.AbstractScheduler):
         """Returns a list of dictionaries of form:
            [ {weight: weight, hostname: hostname, capabilities: capabs} ]
         """
-
         cost_fns = self.get_cost_fns(topic)
         costs = weighted_sum(domain=hosts, weighted_fns=cost_fns)
 
         weighted = []
         weight_log = []
-        for cost, (hostname, caps) in zip(costs, hosts):
+        for cost, (hostname, service) in zip(costs, hosts):
+            caps = service[topic]
             weight_log.append("%s: %s" % (hostname, "%.2f" % cost))
             weight_dict = dict(weight=cost, hostname=hostname,
                     capabilities=caps)
@@ -128,52 +169,3 @@ class LeastCostScheduler(abstract_scheduler.AbstractScheduler):
 
         LOG.debug(_("Weighted Costs => %s") % weight_log)
         return weighted
-
-
-def normalize_list(L):
-    """Normalize an array of numbers such that each element satisfies:
-        0 <= e <= 1"""
-    if not L:
-        return L
-    max_ = max(L)
-    if max_ > 0:
-        return [(float(e) / max_) for e in L]
-    return L
-
-
-def weighted_sum(domain, weighted_fns, normalize=True):
-    """Use the weighted-sum method to compute a score for an array of objects.
-    Normalize the results of the objective-functions so that the weights are
-    meaningful regardless of objective-function's range.
-
-    domain - input to be scored
-    weighted_fns - list of weights and functions like:
-        [(weight, objective-functions)]
-
-    Returns an unsorted list of scores. To pair with hosts do:
-        zip(scores, hosts)
-    """
-    # Table of form:
-    #   { domain1: [score1, score2, ..., scoreM]
-    #     ...
-    #     domainN: [score1, score2, ..., scoreM] }
-    score_table = collections.defaultdict(list)
-    for weight, fn in weighted_fns:
-        scores = [fn(elem) for elem in domain]
-
-        if normalize:
-            norm_scores = normalize_list(scores)
-        else:
-            norm_scores = scores
-
-        for idx, score in enumerate(norm_scores):
-            weighted_score = score * weight
-            score_table[idx].append(weighted_score)
-
-    # Sum rows in table to compute score for each element in domain
-    domain_scores = []
-    for idx in sorted(score_table):
-        elem_score = sum(score_table[idx])
-        domain_scores.append(elem_score)
-
-    return domain_scores
diff --git a/nova/service.py b/nova/service.py
index 6e9eddc5a..959e79052 100644
--- a/nova/service.py
+++ b/nova/service.py
@@ -20,13 +20,11 @@
 """Generic Node baseclass for all workers that run on hosts."""
 
 import inspect
-import multiprocessing
 import os
 
+import eventlet
 import greenlet
 
-from eventlet import greenthread
-
 from nova import context
 from nova import db
 from nova import exception
@@ -69,30 +67,25 @@ class Launcher(object):
         self._services = []
 
     @staticmethod
-    def run_service(service):
-        """Start and wait for a service to finish.
+    def run_server(server):
+        """Start and wait for a server to finish.
 
-        :param service: Service to run and wait for.
+        :param service: Server to run and wait for.
         :returns: None
 
         """
-        service.start()
-        try:
-            service.wait()
-        except KeyboardInterrupt:
-            service.stop()
+        server.start()
+        server.wait()
 
-    def launch_service(self, service):
-        """Load and start the given service.
+    def launch_server(self, server):
+        """Load and start the given server.
 
-        :param service: The service you would like to start.
+        :param server: The server you would like to start.
         :returns: None
 
         """
-        process = multiprocessing.Process(target=self.run_service,
-                                          args=(service,))
-        process.start()
-        self._services.append(process)
+        gt = eventlet.spawn(self.run_server, server)
+        self._services.append(gt)
 
     def stop(self):
         """Stop all services which are currently running.
@@ -101,8 +94,7 @@ class Launcher(object):
 
         """
         for service in self._services:
-            if service.is_alive():
-                service.terminate()
+            service.kill()
 
     def wait(self):
         """Waits until all services have been stopped, and then returns.
@@ -111,11 +103,18 @@ class Launcher(object):
 
         """
         for service in self._services:
-            service.join()
+            try:
+                service.wait()
+            except greenlet.GreenletExit:
+                pass
 
 
 class Service(object):
-    """Base class for workers that run on hosts."""
+    """Service object for binaries running on hosts.
+
+    A service takes a manager and enables rpc by listening to queues based
+    on topic. It also periodically runs tasks on the manager and reports
+    it state to the database services table."""
 
     def __init__(self, host, binary, topic, manager, report_interval=None,
                  periodic_interval=None, *args, **kwargs):
@@ -173,7 +172,7 @@ class Service(object):
             finally:
                 consumer_set.close()
 
-        self.consumer_set_thread = greenthread.spawn(_wait)
+        self.consumer_set_thread = eventlet.spawn(_wait)
 
         if self.report_interval:
             pulse = utils.LoopingCall(self.report_state)
@@ -293,9 +292,9 @@ class WSGIService(object):
     """Provides ability to launch API from a 'paste' configuration."""
 
     def __init__(self, name, loader=None):
-        """Initialize, but do not start the WSGI service.
+        """Initialize, but do not start the WSGI server.
 
-        :param name: The name of the WSGI service given to the loader.
+        :param name: The name of the WSGI server given to the loader.
         :param loader: Loads the WSGI application using the given name.
         :returns: None
 
@@ -339,32 +338,32 @@ class WSGIService(object):
         self.server.wait()
 
 
-def serve(*services):
-    try:
-        if not services:
-            services = [Service.create()]
-    except Exception:
-        logging.exception('in Service.create()')
-        raise
-    finally:
-        # After we've loaded up all our dynamic bits, check
-        # whether we should print help
-        flags.DEFINE_flag(flags.HelpFlag())
-        flags.DEFINE_flag(flags.HelpshortFlag())
-        flags.DEFINE_flag(flags.HelpXMLFlag())
-        FLAGS.ParseNewFlags()
-
-    name = '_'.join(x.binary for x in services)
-    logging.debug(_('Serving %s'), name)
-    logging.debug(_('Full set of FLAGS:'))
-    for flag in FLAGS:
-        flag_get = FLAGS.get(flag, None)
-        logging.debug('%(flag)s : %(flag_get)s' % locals())
+# NOTE(vish): the global launcher is to maintain the existing
+#             functionality of calling service.serve +
+#             service.wait
+_launcher = None
 
-    for x in services:
-        x.start()
+
+def serve(*servers):
+    global _launcher
+    if not _launcher:
+        _launcher = Launcher()
+    for server in servers:
+        _launcher.launch_server(server)
 
 
 def wait():
-    while True:
-        greenthread.sleep(5)
+    # After we've loaded up all our dynamic bits, check
+    # whether we should print help
+    flags.DEFINE_flag(flags.HelpFlag())
+    flags.DEFINE_flag(flags.HelpshortFlag())
+    flags.DEFINE_flag(flags.HelpXMLFlag())
+    FLAGS.ParseNewFlags()
+    logging.debug(_('Full set of FLAGS:'))
+    for flag in FLAGS:
+        flag_get = FLAGS.get(flag, None)
+        logging.debug('%(flag)s : %(flag_get)s' % locals())
+    try:
+        _launcher.wait()
+    except KeyboardInterrupt:
+        _launcher.stop()
diff --git a/nova/tests/api/openstack/contrib/test_floating_ips.py b/nova/tests/api/openstack/contrib/test_floating_ips.py
index 704d06582..d2ca9c365 100644
--- a/nova/tests/api/openstack/contrib/test_floating_ips.py
+++ b/nova/tests/api/openstack/contrib/test_floating_ips.py
@@ -17,6 +17,7 @@ import json
 import stubout
 import webob
 
+from nova import compute
 from nova import context
 from nova import db
 from nova import test
@@ -30,6 +31,11 @@ from nova.api.openstack.contrib.floating_ips import _translate_floating_ip_view
 
 def network_api_get_floating_ip(self, context, id):
     return {'id': 1, 'address': '10.10.10.10',
+            'fixed_ip': None}
+
+
+def network_api_get_floating_ip_by_ip(self, context, address):
+    return {'id': 1, 'address': '10.10.10.10',
             'fixed_ip': {'address': '11.0.0.1'}}
 
 
@@ -50,7 +56,7 @@ def network_api_release(self, context, address):
     pass
 
 
-def network_api_associate(self, context, floating_ip, fixed_ip):
+def compute_api_associate(self, context, instance_id, floating_ip):
     pass
 
 
@@ -78,14 +84,16 @@ class FloatingIpTest(test.TestCase):
         fakes.stub_out_rate_limiting(self.stubs)
         self.stubs.Set(network.api.API, "get_floating_ip",
                        network_api_get_floating_ip)
+        self.stubs.Set(network.api.API, "get_floating_ip_by_ip",
+                       network_api_get_floating_ip)
         self.stubs.Set(network.api.API, "list_floating_ips",
                        network_api_list_floating_ips)
         self.stubs.Set(network.api.API, "allocate_floating_ip",
                        network_api_allocate)
         self.stubs.Set(network.api.API, "release_floating_ip",
                        network_api_release)
-        self.stubs.Set(network.api.API, "associate_floating_ip",
-                       network_api_associate)
+        self.stubs.Set(compute.api.API, "associate_floating_ip",
+                       compute_api_associate)
         self.stubs.Set(network.api.API, "disassociate_floating_ip",
                        network_api_disassociate)
         self.context = context.get_admin_context()
@@ -133,7 +141,6 @@ class FloatingIpTest(test.TestCase):
         res_dict = json.loads(res.body)
         self.assertEqual(res_dict['floating_ip']['id'], 1)
         self.assertEqual(res_dict['floating_ip']['ip'], '10.10.10.10')
-        self.assertEqual(res_dict['floating_ip']['fixed_ip'], '11.0.0.1')
         self.assertEqual(res_dict['floating_ip']['instance_id'], None)
 
     def test_floating_ip_allocate(self):
@@ -141,51 +148,78 @@ class FloatingIpTest(test.TestCase):
         req.method = 'POST'
         req.headers['Content-Type'] = 'application/json'
         res = req.get_response(fakes.wsgi_app())
-        print res
         self.assertEqual(res.status_int, 200)
-        ip = json.loads(res.body)['allocated']
+        ip = json.loads(res.body)['floating_ip']
+
         expected = {
             "id": 1,
-            "floating_ip": '10.10.10.10'}
+            "instance_id": None,
+            "ip": "10.10.10.10",
+            "fixed_ip": None}
         self.assertEqual(ip, expected)
 
     def test_floating_ip_release(self):
         req = webob.Request.blank('/v1.1/os-floating-ips/1')
         req.method = 'DELETE'
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-        actual = json.loads(res.body)['released']
-        expected = {
-            "id": 1,
-            "floating_ip": '10.10.10.10'}
-        self.assertEqual(actual, expected)
+        self.assertEqual(res.status_int, 202)
 
-    def test_floating_ip_associate(self):
-        body = dict(associate_address=dict(fixed_ip='1.2.3.4'))
-        req = webob.Request.blank('/v1.1/os-floating-ips/1/associate')
-        req.method = 'POST'
+    def test_add_floating_ip_to_instance(self):
+        body = dict(addFloatingIp=dict(address='11.0.0.1'))
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
         req.body = json.dumps(body)
         req.headers["content-type"] = "application/json"
 
-        res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-        actual = json.loads(res.body)['associated']
-        expected = {
-            "floating_ip_id": '1',
-            "floating_ip": "10.10.10.10",
-            "fixed_ip": "1.2.3.4"}
-        self.assertEqual(actual, expected)
-
-    def test_floating_ip_disassociate(self):
-        body = dict()
-        req = webob.Request.blank('/v1.1/os-floating-ips/1/disassociate')
-        req.method = 'POST'
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 202)
+
+    def test_remove_floating_ip_from_instance(self):
+        body = dict(removeFloatingIp=dict(address='11.0.0.1'))
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
         req.body = json.dumps(body)
-        req.headers['Content-Type'] = 'application/json'
-        res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(res.status_int, 200)
-        ip = json.loads(res.body)['disassociated']
-        expected = {
-            "floating_ip": '10.10.10.10',
-            "fixed_ip": '11.0.0.1'}
-        self.assertEqual(ip, expected)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 202)
+
+    def test_bad_address_param_in_remove_floating_ip(self):
+        body = dict(removeFloatingIp=dict(badparam='11.0.0.1'))
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 400)
+
+    def test_missing_dict_param_in_remove_floating_ip(self):
+        body = dict(removeFloatingIp='11.0.0.1')
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 400)
+
+    def test_bad_address_param_in_add_floating_ip(self):
+        body = dict(addFloatingIp=dict(badparam='11.0.0.1'))
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 400)
+
+    def test_missing_dict_param_in_add_floating_ip(self):
+        body = dict(addFloatingIp='11.0.0.1')
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 400)
diff --git a/nova/tests/api/openstack/contrib/test_quotas.py b/nova/tests/api/openstack/contrib/test_quotas.py
new file mode 100644
index 000000000..f6a25385f
--- /dev/null
+++ b/nova/tests/api/openstack/contrib/test_quotas.py
@@ -0,0 +1,152 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 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.
+
+import json
+import webob
+
+from nova import context
+from nova import test
+from nova.tests.api.openstack import fakes
+
+from nova.api.openstack.contrib.quotas import QuotaSetsController
+
+
+def quota_set(id):
+    return {'quota_set': {'id': id, 'metadata_items': 128, 'volumes': 10,
+            'gigabytes': 1000, 'ram': 51200, 'floating_ips': 10,
+            'instances': 10, 'injected_files': 5, 'cores': 20,
+            'injected_file_content_bytes': 10240}}
+
+
+def quota_set_list():
+    return {'quota_set_list': [quota_set('1234'), quota_set('5678'),
+                               quota_set('update_me')]}
+
+
+class QuotaSetsTest(test.TestCase):
+
+    def setUp(self):
+        super(QuotaSetsTest, self).setUp()
+        self.controller = QuotaSetsController()
+        self.user_id = 'fake'
+        self.project_id = 'fake'
+        self.user_context = context.RequestContext(self.user_id,
+                                                   self.project_id)
+        self.admin_context = context.RequestContext(self.user_id,
+                                                    self.project_id,
+                                                    is_admin=True)
+
+    def test_format_quota_set(self):
+        raw_quota_set = {
+            'instances': 10,
+            'cores': 20,
+            'ram': 51200,
+            'volumes': 10,
+            'floating_ips': 10,
+            'metadata_items': 128,
+            'gigabytes': 1000,
+            'injected_files': 5,
+            'injected_file_content_bytes': 10240}
+
+        quota_set = QuotaSetsController()._format_quota_set('1234',
+                                                            raw_quota_set)
+        qs = quota_set['quota_set']
+
+        self.assertEqual(qs['id'], '1234')
+        self.assertEqual(qs['instances'], 10)
+        self.assertEqual(qs['cores'], 20)
+        self.assertEqual(qs['ram'], 51200)
+        self.assertEqual(qs['volumes'], 10)
+        self.assertEqual(qs['gigabytes'], 1000)
+        self.assertEqual(qs['floating_ips'], 10)
+        self.assertEqual(qs['metadata_items'], 128)
+        self.assertEqual(qs['injected_files'], 5)
+        self.assertEqual(qs['injected_file_content_bytes'], 10240)
+
+    def test_quotas_defaults(self):
+        req = webob.Request.blank('/v1.1/os-quota-sets/fake_tenant/defaults')
+        req.method = 'GET'
+        req.headers['Content-Type'] = 'application/json'
+        res = req.get_response(fakes.wsgi_app())
+
+        self.assertEqual(res.status_int, 200)
+        expected = {'quota_set': {
+                    'id': 'fake_tenant',
+                    'instances': 10,
+                    'cores': 20,
+                    'ram': 51200,
+                    'volumes': 10,
+                    'gigabytes': 1000,
+                    'floating_ips': 10,
+                    'metadata_items': 128,
+                    'injected_files': 5,
+                    'injected_file_content_bytes': 10240}}
+
+        self.assertEqual(json.loads(res.body), expected)
+
+    def test_quotas_show_as_admin(self):
+        req = webob.Request.blank('/v1.1/os-quota-sets/1234')
+        req.method = 'GET'
+        req.headers['Content-Type'] = 'application/json'
+        res = req.get_response(fakes.wsgi_app(
+                               fake_auth_context=self.admin_context))
+
+        self.assertEqual(res.status_int, 200)
+        self.assertEqual(json.loads(res.body), quota_set('1234'))
+
+    def test_quotas_show_as_unauthorized_user(self):
+        req = webob.Request.blank('/v1.1/os-quota-sets/1234')
+        req.method = 'GET'
+        req.headers['Content-Type'] = 'application/json'
+        res = req.get_response(fakes.wsgi_app(
+                               fake_auth_context=self.user_context))
+
+        self.assertEqual(res.status_int, 403)
+
+    def test_quotas_update_as_admin(self):
+        updated_quota_set = {'quota_set': {'instances': 50,
+                             'cores': 50, 'ram': 51200, 'volumes': 10,
+                             'gigabytes': 1000, 'floating_ips': 10,
+                             'metadata_items': 128, 'injected_files': 5,
+                             'injected_file_content_bytes': 10240}}
+
+        req = webob.Request.blank('/v1.1/os-quota-sets/update_me')
+        req.method = 'PUT'
+        req.body = json.dumps(updated_quota_set)
+        req.headers['Content-Type'] = 'application/json'
+
+        res = req.get_response(fakes.wsgi_app(
+                               fake_auth_context=self.admin_context))
+
+        self.assertEqual(json.loads(res.body), updated_quota_set)
+
+    def test_quotas_update_as_user(self):
+        updated_quota_set = {'quota_set': {'instances': 50,
+                             'cores': 50, 'ram': 51200, 'volumes': 10,
+                             'gigabytes': 1000, 'floating_ips': 10,
+                             'metadata_items': 128, 'injected_files': 5,
+                             'injected_file_content_bytes': 10240}}
+
+        req = webob.Request.blank('/v1.1/os-quota-sets/update_me')
+        req.method = 'PUT'
+        req.body = json.dumps(updated_quota_set)
+        req.headers['Content-Type'] = 'application/json'
+
+        res = req.get_response(fakes.wsgi_app(
+                               fake_auth_context=self.user_context))
+
+        self.assertEqual(res.status_int, 403)
diff --git a/nova/tests/api/openstack/contrib/test_rescue.py b/nova/tests/api/openstack/contrib/test_rescue.py
new file mode 100644
index 000000000..fc8e4be4e
--- /dev/null
+++ b/nova/tests/api/openstack/contrib/test_rescue.py
@@ -0,0 +1,55 @@
+#   Copyright 2011 OpenStack LLC.
+#
+#   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 json
+import webob
+
+from nova import compute
+from nova import test
+from nova.tests.api.openstack import fakes
+
+
+def rescue(self, context, instance_id):
+    pass
+
+
+def unrescue(self, context, instance_id):
+    pass
+
+
+class RescueTest(test.TestCase):
+    def setUp(self):
+        super(RescueTest, self).setUp()
+        self.stubs.Set(compute.api.API, "rescue", rescue)
+        self.stubs.Set(compute.api.API, "unrescue", unrescue)
+
+    def test_rescue(self):
+        body = dict(rescue=None)
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 200)
+
+    def test_unrescue(self):
+        body = dict(unrescue=None)
+        req = webob.Request.blank('/v1.1/servers/test_inst/action')
+        req.method = "POST"
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        resp = req.get_response(fakes.wsgi_app())
+        self.assertEqual(resp.status_int, 200)
diff --git a/nova/tests/api/openstack/contrib/test_security_groups.py b/nova/tests/api/openstack/contrib/test_security_groups.py
index 4317880ca..b44ebc9fb 100644
--- a/nova/tests/api/openstack/contrib/test_security_groups.py
+++ b/nova/tests/api/openstack/contrib/test_security_groups.py
@@ -15,10 +15,13 @@
 #    under the License.
 
 import json
+import mox
+import nova
 import unittest
 import webob
 from xml.dom import minidom
 
+from nova import exception
 from nova import test
 from nova.api.openstack.contrib import security_groups
 from nova.tests.api.openstack import fakes
@@ -51,6 +54,28 @@ def _create_security_group_request_dict(security_group):
     return {'security_group': sg}
 
 
+def return_server(context, server_id):
+    return {'id': server_id, 'state': 0x01, 'host': "localhost"}
+
+
+def return_non_running_server(context, server_id):
+    return {'id': server_id, 'state': 0x02,
+                        'host': "localhost"}
+
+
+def return_security_group(context, project_id, group_name):
+    return {'id': 1, 'name': group_name, "instances": [
+              {'id': 1}]}
+
+
+def return_security_group_without_instances(context, project_id, group_name):
+    return {'id': 1, 'name': group_name}
+
+
+def return_server_nonexistant(context, server_id):
+    raise exception.InstanceNotFound(instance_id=server_id)
+
+
 class TestSecurityGroups(test.TestCase):
     def setUp(self):
         super(TestSecurityGroups, self).setUp()
@@ -325,6 +350,252 @@ class TestSecurityGroups(test.TestCase):
         response = self._delete_security_group(11111111)
         self.assertEquals(response.status_int, 404)
 
+    def test_associate_by_non_existing_security_group_name(self):
+        body = dict(addSecurityGroup=dict(name='non-existing'))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 404)
+
+    def test_associate_by_invalid_server_id(self):
+        body = dict(addSecurityGroup=dict(name='test'))
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        req = webob.Request.blank('/v1.1/servers/invalid/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_associate_without_body(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        body = dict(addSecurityGroup=None)
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_associate_no_security_group_name(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        body = dict(addSecurityGroup=dict())
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_associate_security_group_name_with_whitespaces(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        body = dict(addSecurityGroup=dict(name="   "))
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_associate_non_existing_instance(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server_nonexistant)
+        body = dict(addSecurityGroup=dict(name="test"))
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        req = webob.Request.blank('/v1.1/servers/10000/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 404)
+
+    def test_associate_non_running_instance(self):
+        self.stubs.Set(nova.db, 'instance_get', return_non_running_server)
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group_without_instances)
+        body = dict(addSecurityGroup=dict(name="test"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_associate_already_associated_security_group_to_instance(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        body = dict(addSecurityGroup=dict(name="test"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_associate(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        self.mox.StubOutWithMock(nova.db, 'instance_add_security_group')
+        nova.db.instance_add_security_group(mox.IgnoreArg(),
+                                    mox.IgnoreArg(),
+                                    mox.IgnoreArg())
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group_without_instances)
+        self.mox.ReplayAll()
+
+        body = dict(addSecurityGroup=dict(name="test"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 202)
+
+    def test_associate_xml(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        self.mox.StubOutWithMock(nova.db, 'instance_add_security_group')
+        nova.db.instance_add_security_group(mox.IgnoreArg(),
+                                    mox.IgnoreArg(),
+                                    mox.IgnoreArg())
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group_without_instances)
+        self.mox.ReplayAll()
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/xml'
+        req.method = 'POST'
+        req.body = """<addSecurityGroup>
+                           <name>test</name>
+                    </addSecurityGroup>"""
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 202)
+
+    def test_disassociate_by_non_existing_security_group_name(self):
+        body = dict(removeSecurityGroup=dict(name='non-existing'))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 404)
+
+    def test_disassociate_by_invalid_server_id(self):
+        body = dict(removeSecurityGroup=dict(name='test'))
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        req = webob.Request.blank('/v1.1/servers/invalid/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_disassociate_without_body(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        body = dict(removeSecurityGroup=None)
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_disassociate_no_security_group_name(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        body = dict(removeSecurityGroup=dict())
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_disassociate_security_group_name_with_whitespaces(self):
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        body = dict(removeSecurityGroup=dict(name="   "))
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_disassociate_non_existing_instance(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server_nonexistant)
+        body = dict(removeSecurityGroup=dict(name="test"))
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        req = webob.Request.blank('/v1.1/servers/10000/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 404)
+
+    def test_disassociate_non_running_instance(self):
+        self.stubs.Set(nova.db, 'instance_get', return_non_running_server)
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        body = dict(removeSecurityGroup=dict(name="test"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_disassociate_already_associated_security_group_to_instance(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group_without_instances)
+        body = dict(removeSecurityGroup=dict(name="test"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 400)
+
+    def test_disassociate(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        self.mox.StubOutWithMock(nova.db, 'instance_remove_security_group')
+        nova.db.instance_remove_security_group(mox.IgnoreArg(),
+                                    mox.IgnoreArg(),
+                                    mox.IgnoreArg())
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        self.mox.ReplayAll()
+
+        body = dict(removeSecurityGroup=dict(name="test"))
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/json'
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 202)
+
+    def test_disassociate_xml(self):
+        self.stubs.Set(nova.db, 'instance_get', return_server)
+        self.mox.StubOutWithMock(nova.db, 'instance_remove_security_group')
+        nova.db.instance_remove_security_group(mox.IgnoreArg(),
+                                    mox.IgnoreArg(),
+                                    mox.IgnoreArg())
+        self.stubs.Set(nova.db, 'security_group_get_by_name',
+                       return_security_group)
+        self.mox.ReplayAll()
+
+        req = webob.Request.blank('/v1.1/servers/1/action')
+        req.headers['Content-Type'] = 'application/xml'
+        req.method = 'POST'
+        req.body = """<removeSecurityGroup>
+                           <name>test</name>
+                    </removeSecurityGroup>"""
+        response = req.get_response(fakes.wsgi_app())
+        self.assertEquals(response.status_int, 202)
+
 
 class TestSecurityGroupRules(test.TestCase):
     def setUp(self):
diff --git a/nova/tests/api/openstack/contrib/test_virtual_interfaces.py b/nova/tests/api/openstack/contrib/test_virtual_interfaces.py
new file mode 100644
index 000000000..d541a9e95
--- /dev/null
+++ b/nova/tests/api/openstack/contrib/test_virtual_interfaces.py
@@ -0,0 +1,55 @@
+# Copyright (C) 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 json
+import stubout
+import webob
+
+from nova import test
+from nova import compute
+from nova.tests.api.openstack import fakes
+from nova.api.openstack.contrib.virtual_interfaces import \
+    ServerVirtualInterfaceController
+
+
+def compute_api_get(self, context, server_id):
+    return {'virtual_interfaces': [
+                {'uuid': '00000000-0000-0000-0000-00000000000000000',
+                 'address': '00-00-00-00-00-00'},
+                {'uuid': '11111111-1111-1111-1111-11111111111111111',
+                 'address': '11-11-11-11-11-11'}]}
+
+
+class ServerVirtualInterfaceTest(test.TestCase):
+
+    def setUp(self):
+        super(ServerVirtualInterfaceTest, self).setUp()
+        self.controller = ServerVirtualInterfaceController()
+        self.stubs.Set(compute.api.API, "get", compute_api_get)
+
+    def tearDown(self):
+        super(ServerVirtualInterfaceTest, self).tearDown()
+
+    def test_get_virtual_interfaces_list(self):
+        req = webob.Request.blank('/v1.1/servers/1/os-virtual-interfaces')
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
+        response = {'virtual_interfaces': [
+                        {'id': '00000000-0000-0000-0000-00000000000000000',
+                         'mac_address': '00-00-00-00-00-00'},
+                        {'id': '11111111-1111-1111-1111-11111111111111111',
+                         'mac_address': '11-11-11-11-11-11'}]}
+        self.assertEqual(res_dict, response)
diff --git a/nova/tests/api/openstack/fakes.py b/nova/tests/api/openstack/fakes.py
index d11fbf788..a095dd90a 100644
--- a/nova/tests/api/openstack/fakes.py
+++ b/nova/tests/api/openstack/fakes.py
@@ -32,6 +32,7 @@ from nova import utils
 from nova import wsgi
 import nova.api.openstack.auth
 from nova.api import openstack
+from nova.api import auth as api_auth
 from nova.api.openstack import auth
 from nova.api.openstack import extensions
 from nova.api.openstack import versions
@@ -83,9 +84,9 @@ def wsgi_app(inner_app10=None, inner_app11=None, fake_auth=True,
             ctxt = fake_auth_context
         else:
             ctxt = context.RequestContext('fake', 'fake')
-        api10 = openstack.FaultWrapper(wsgi.InjectContext(ctxt,
+        api10 = openstack.FaultWrapper(api_auth.InjectContext(ctxt,
               limits.RateLimitingMiddleware(inner_app10)))
-        api11 = openstack.FaultWrapper(wsgi.InjectContext(ctxt,
+        api11 = openstack.FaultWrapper(api_auth.InjectContext(ctxt,
               limits.RateLimitingMiddleware(
                   extensions.ExtensionMiddleware(inner_app11))))
     else:
diff --git a/nova/tests/api/openstack/test_extensions.py b/nova/tests/api/openstack/test_extensions.py
index 3e990a30b..d89cb28d6 100644
--- a/nova/tests/api/openstack/test_extensions.py
+++ b/nova/tests/api/openstack/test_extensions.py
@@ -91,7 +91,10 @@ class ExtensionControllerTest(test.TestCase):
             "Hosts",
             "Keypairs",
             "Multinic",
+            "Quotas",
+            "Rescue",
             "SecurityGroups",
+            "VirtualInterfaces",
             "Volumes",
             ]
         self.ext_list.sort()
@@ -110,7 +113,7 @@ class ExtensionControllerTest(test.TestCase):
         self.assertEqual(names, self.ext_list)
 
         # Make sure that at least Fox in Sox is correct.
-        (fox_ext,) = [
+        (fox_ext, ) = [
             x for x in data['extensions'] if x['alias'] == 'FOXNSOX']
         self.assertEqual(fox_ext, {
                 'namespace': 'http://www.fox.in.socks/api/ext/pie/v1.0',
@@ -155,7 +158,7 @@ class ExtensionControllerTest(test.TestCase):
         self.assertEqual(len(exts), len(self.ext_list))
 
         # Make sure that at least Fox in Sox is correct.
-        (fox_ext,) = [x for x in exts if x.get('alias') == 'FOXNSOX']
+        (fox_ext, ) = [x for x in exts if x.get('alias') == 'FOXNSOX']
         self.assertEqual(fox_ext.get('name'), 'Fox In Socks')
         self.assertEqual(fox_ext.get('namespace'),
             'http://www.fox.in.socks/api/ext/pie/v1.0')
@@ -227,6 +230,7 @@ class ResourceExtensionTest(test.TestCase):
 
 
 class InvalidExtension(object):
+
     def get_alias(self):
         return "THIRD"
 
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 56a0932e7..21743eeef 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -230,7 +230,7 @@ class ImageMetaDataTest(test.TestCase):
         req.body = json_string
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, res.status_int)
+        self.assertEqual(413, res.status_int)
 
     def test_too_many_metadata_items_on_put(self):
         req = webob.Request.blank('/v1.1/images/3/metadata/blah')
@@ -238,4 +238,4 @@ class ImageMetaDataTest(test.TestCase):
         req.body = '{"meta": {"blah": "blah"}}'
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, res.status_int)
+        self.assertEqual(413, res.status_int)
diff --git a/nova/tests/api/openstack/test_server_actions.py b/nova/tests/api/openstack/test_server_actions.py
index 687a19390..80a27e30f 100644
--- a/nova/tests/api/openstack/test_server_actions.py
+++ b/nova/tests/api/openstack/test_server_actions.py
@@ -392,7 +392,7 @@ class ServerActionsTest(test.TestCase):
         req.body = json.dumps(body)
         req.headers["content-type"] = "application/json"
         response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
+        self.assertEqual(413, response.status_int)
 
     def test_create_backup_no_name(self):
         """Name is required for backups"""
@@ -865,7 +865,7 @@ class ServerActionsTestV11(test.TestCase):
         req.body = json.dumps(body)
         req.headers["content-type"] = "application/json"
         response = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, response.status_int)
+        self.assertEqual(413, response.status_int)
 
     def test_create_image_no_name(self):
         body = {
diff --git a/nova/tests/api/openstack/test_server_metadata.py b/nova/tests/api/openstack/test_server_metadata.py
index ec446f0f0..8512bd518 100644
--- a/nova/tests/api/openstack/test_server_metadata.py
+++ b/nova/tests/api/openstack/test_server_metadata.py
@@ -417,9 +417,9 @@ class ServerMetaDataTest(test.TestCase):
         req.body = json_string
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
-        self.assertEqual(400, res.status_int)
+        self.assertEqual(413, res.status_int)
 
-    def test_to_many_metadata_items_on_update_item(self):
+    def test_too_many_metadata_items_on_update_item(self):
         self.stubs.Set(nova.db.api, 'instance_metadata_update',
                        return_create_instance_metadata_max)
         req = webob.Request.blank('/v1.1/servers/1/metadata/key1')
diff --git a/nova/tests/api/openstack/test_servers.py b/nova/tests/api/openstack/test_servers.py
index a510d7d97..d3eb4c517 100644
--- a/nova/tests/api/openstack/test_servers.py
+++ b/nova/tests/api/openstack/test_servers.py
@@ -19,6 +19,7 @@ import base64
 import datetime
 import json
 import unittest
+from lxml import etree
 from xml.dom import minidom
 
 import webob
@@ -32,6 +33,7 @@ import nova.api.openstack
 from nova.api.openstack import create_instance_helper
 from nova.api.openstack import servers
 from nova.api.openstack import wsgi
+from nova.api.openstack import xmlutil
 import nova.compute.api
 from nova.compute import instance_types
 from nova.compute import power_state
@@ -46,6 +48,8 @@ from nova.tests.api.openstack import fakes
 
 
 FAKE_UUID = 'aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa'
+NS = "{http://docs.openstack.org/compute/api/v1.1}"
+ATOMNS = "{http://www.w3.org/2005/Atom}"
 
 
 def fake_gen_uuid():
@@ -145,7 +149,8 @@ def instance_addresses(context, instance_id):
 def stub_instance(id, user_id='fake', project_id='fake', private_address=None,
                   public_addresses=None, host=None, power_state=0,
                   reservation_id="", uuid=FAKE_UUID, image_ref="10",
-                  flavor_id="1", interfaces=None, name=None):
+                  flavor_id="1", interfaces=None, name=None,
+                  access_ipv4=None, access_ipv6=None):
     metadata = []
     metadata.append(InstanceMetadata(key='seq', value=id))
 
@@ -197,6 +202,8 @@ def stub_instance(id, user_id='fake', project_id='fake', private_address=None,
         "display_description": "",
         "locked": False,
         "metadata": metadata,
+        "access_ip_v4": access_ipv4,
+        "access_ip_v6": access_ipv6,
         "uuid": uuid,
         "virtual_interfaces": interfaces}
 
@@ -334,6 +341,8 @@ class ServersTest(test.TestCase):
                 "progress": 0,
                 "name": "server1",
                 "status": "BUILD",
+                "accessIPv4": "",
+                "accessIPv6": "",
                 "hostId": '',
                 "image": {
                     "id": "10",
@@ -431,6 +440,8 @@ class ServersTest(test.TestCase):
                 created="%(expected_created)s"
                 hostId=""
                 status="BUILD"
+                accessIPv4=""
+                accessIPv6=""
                 progress="0">
             <atom:link href="%(server_href)s" rel="self"/>
             <atom:link href="%(server_bookmark)s" rel="bookmark"/>
@@ -496,6 +507,8 @@ class ServersTest(test.TestCase):
                 "progress": 100,
                 "name": "server1",
                 "status": "ACTIVE",
+                "accessIPv4": "",
+                "accessIPv6": "",
                 "hostId": '',
                 "image": {
                     "id": "10",
@@ -587,6 +600,8 @@ class ServersTest(test.TestCase):
                 "progress": 100,
                 "name": "server1",
                 "status": "ACTIVE",
+                "accessIPv4": "",
+                "accessIPv6": "",
                 "hostId": '',
                 "image": {
                     "id": "10",
@@ -1379,6 +1394,8 @@ class ServersTest(test.TestCase):
                     'display_name': 'server_test',
                     'uuid': FAKE_UUID,
                     'instance_type': dict(inst_type),
+                    'access_ip_v4': '1.2.3.4',
+                    'access_ip_v6': 'fead::1234',
                     'image_ref': image_ref,
                     "created_at": datetime.datetime(2010, 10, 10, 12, 0, 0),
                     "updated_at": datetime.datetime(2010, 11, 11, 11, 0, 0),
@@ -1579,6 +1596,70 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_create_instance_with_access_ip_v1_1(self):
+        self._setup_for_create_instance()
+
+        # proper local hrefs must start with 'http://localhost/v1.1/'
+        image_href = 'http://localhost/v1.1/images/2'
+        flavor_ref = 'http://localhost/flavors/3'
+        access_ipv4 = '1.2.3.4'
+        access_ipv6 = 'fead::1234'
+        expected_flavor = {
+            "id": "3",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/flavors/3',
+                },
+            ],
+        }
+        expected_image = {
+            "id": "2",
+            "links": [
+                {
+                    "rel": "bookmark",
+                    "href": 'http://localhost/images/2',
+                },
+            ],
+        }
+        body = {
+            'server': {
+                'name': 'server_test',
+                'imageRef': image_href,
+                'flavorRef': flavor_ref,
+                'accessIPv4': access_ipv4,
+                'accessIPv6': access_ipv6,
+                'metadata': {
+                    'hello': 'world',
+                    'open': 'stack',
+                },
+                'personality': [
+                    {
+                        "path": "/etc/banner.txt",
+                        "contents": "MQ==",
+                    },
+                ],
+            },
+        }
+
+        req = webob.Request.blank('/v1.1/servers')
+        req.method = 'POST'
+        req.body = json.dumps(body)
+        req.headers["content-type"] = "application/json"
+
+        res = req.get_response(fakes.wsgi_app())
+
+        self.assertEqual(res.status_int, 202)
+        server = json.loads(res.body)['server']
+        self.assertEqual(16, len(server['adminPass']))
+        self.assertEqual(1, server['id'])
+        self.assertEqual(0, server['progress'])
+        self.assertEqual('server_test', server['name'])
+        self.assertEqual(expected_flavor, server['flavor'])
+        self.assertEqual(expected_image, server['image'])
+        self.assertEqual(access_ipv4, server['accessIPv4'])
+        self.assertEqual(access_ipv6, server['accessIPv6'])
+
     def test_create_instance_v1_1(self):
         self._setup_for_create_instance()
 
@@ -1636,6 +1717,8 @@ class ServersTest(test.TestCase):
         self.assertEqual('server_test', server['name'])
         self.assertEqual(expected_flavor, server['flavor'])
         self.assertEqual(expected_image, server['image'])
+        self.assertEqual('1.2.3.4', server['accessIPv4'])
+        self.assertEqual('fead::1234', server['accessIPv6'])
 
     def test_create_instance_v1_1_invalid_flavor_href(self):
         self._setup_for_create_instance()
@@ -1879,6 +1962,28 @@ class ServersTest(test.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(res.status_int, 400)
 
+    def test_update_server_all_attributes_v1_1(self):
+        self.stubs.Set(nova.db.api, 'instance_get',
+                return_server_with_attributes(name='server_test',
+                                              access_ipv4='0.0.0.0',
+                                              access_ipv6='beef::0123'))
+        req = webob.Request.blank('/v1.1/servers/1')
+        req.method = 'PUT'
+        req.content_type = 'application/json'
+        body = {'server': {
+                  'name': 'server_test',
+                  'accessIPv4': '0.0.0.0',
+                  'accessIPv6': 'beef::0123',
+               }}
+        req.body = json.dumps(body)
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['name'], 'server_test')
+        self.assertEqual(res_dict['server']['accessIPv4'], '0.0.0.0')
+        self.assertEqual(res_dict['server']['accessIPv6'], 'beef::0123')
+
     def test_update_server_name_v1_1(self):
         self.stubs.Set(nova.db.api, 'instance_get',
                 return_server_with_attributes(name='server_test'))
@@ -1892,6 +1997,32 @@ class ServersTest(test.TestCase):
         self.assertEqual(res_dict['server']['id'], 1)
         self.assertEqual(res_dict['server']['name'], 'server_test')
 
+    def test_update_server_access_ipv4_v1_1(self):
+        self.stubs.Set(nova.db.api, 'instance_get',
+                return_server_with_attributes(access_ipv4='0.0.0.0'))
+        req = webob.Request.blank('/v1.1/servers/1')
+        req.method = 'PUT'
+        req.content_type = 'application/json'
+        req.body = json.dumps({'server': {'accessIPv4': '0.0.0.0'}})
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['accessIPv4'], '0.0.0.0')
+
+    def test_update_server_access_ipv6_v1_1(self):
+        self.stubs.Set(nova.db.api, 'instance_get',
+                return_server_with_attributes(access_ipv6='beef::0123'))
+        req = webob.Request.blank('/v1.1/servers/1')
+        req.method = 'PUT'
+        req.content_type = 'application/json'
+        req.body = json.dumps({'server': {'accessIPv6': 'beef::0123'}})
+        res = req.get_response(fakes.wsgi_app())
+        self.assertEqual(res.status_int, 200)
+        res_dict = json.loads(res.body)
+        self.assertEqual(res_dict['server']['id'], 1)
+        self.assertEqual(res_dict['server']['accessIPv6'], 'beef::0123')
+
     def test_update_server_adminPass_ignored_v1_1(self):
         inst_dict = dict(name='server_test', adminPass='bacon')
         self.body = json.dumps(dict(server=inst_dict))
@@ -2491,6 +2622,62 @@ class TestServerCreateRequestXMLDeserializerV11(test.TestCase):
         }
         self.assertEquals(request['body'], expected)
 
+    def test_access_ipv4(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+        name="new-server-test"
+        imageRef="1"
+        flavorRef="2"
+        accessIPv4="1.2.3.4"/>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {
+            "server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "2",
+                "accessIPv4": "1.2.3.4",
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_access_ipv6(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+        name="new-server-test"
+        imageRef="1"
+        flavorRef="2"
+        accessIPv6="fead::1234"/>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {
+            "server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "2",
+                "accessIPv6": "fead::1234",
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
+    def test_access_ip(self):
+        serial_request = """
+<server xmlns="http://docs.openstack.org/compute/api/v1.1"
+        name="new-server-test"
+        imageRef="1"
+        flavorRef="2"
+        accessIPv4="1.2.3.4"
+        accessIPv6="fead::1234"/>"""
+        request = self.deserializer.deserialize(serial_request, 'create')
+        expected = {
+            "server": {
+                "name": "new-server-test",
+                "imageRef": "1",
+                "flavorRef": "2",
+                "accessIPv4": "1.2.3.4",
+                "accessIPv6": "fead::1234",
+            },
+        }
+        self.assertEquals(request['body'], expected)
+
     def test_admin_pass(self):
         serial_request = """
 <server xmlns="http://docs.openstack.org/compute/api/v1.1"
@@ -3039,6 +3226,8 @@ class ServersViewBuilderV11Test(test.TestCase):
             "display_description": "",
             "locked": False,
             "metadata": [],
+            "accessIPv4": "1.2.3.4",
+            "accessIPv6": "fead::1234",
             #"address": ,
             #"floating_ips": [{"address":ip} for ip in public_addresses]}
             "uuid": "deadbeef-feed-edee-beef-d0ea7beefedd"}
@@ -3093,6 +3282,8 @@ class ServersViewBuilderV11Test(test.TestCase):
                 "progress": 0,
                 "name": "test_server",
                 "status": "BUILD",
+                "accessIPv4": "",
+                "accessIPv6": "",
                 "hostId": '',
                 "image": {
                     "id": "5",
@@ -3144,6 +3335,8 @@ class ServersViewBuilderV11Test(test.TestCase):
                 "progress": 100,
                 "name": "test_server",
                 "status": "ACTIVE",
+                "accessIPv4": "",
+                "accessIPv6": "",
                 "hostId": '',
                 "image": {
                     "id": "5",
@@ -3181,6 +3374,114 @@ class ServersViewBuilderV11Test(test.TestCase):
         output = self.view_builder.build(self.instance, True)
         self.assertDictMatch(output, expected_server)
 
+    def test_build_server_detail_with_accessipv4(self):
+
+        self.instance['access_ip_v4'] = '1.2.3.4'
+
+        image_bookmark = "http://localhost/images/5"
+        flavor_bookmark = "http://localhost/flavors/1"
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": self.instance['uuid'],
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 0,
+                "name": "test_server",
+                "status": "BUILD",
+                "hostId": '',
+                "image": {
+                    "id": "5",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                    "links": [
+                                              {
+                            "rel": "bookmark",
+                            "href": flavor_bookmark,
+                        },
+                    ],
+                },
+                "addresses": {},
+                "metadata": {},
+                "accessIPv4": "1.2.3.4",
+                "accessIPv6": "",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        output = self.view_builder.build(self.instance, True)
+        self.assertDictMatch(output, expected_server)
+
+    def test_build_server_detail_with_accessipv6(self):
+
+        self.instance['access_ip_v6'] = 'fead::1234'
+
+        image_bookmark = "http://localhost/images/5"
+        flavor_bookmark = "http://localhost/flavors/1"
+        expected_server = {
+            "server": {
+                "id": 1,
+                "uuid": self.instance['uuid'],
+                "updated": "2010-11-11T11:00:00Z",
+                "created": "2010-10-10T12:00:00Z",
+                "progress": 0,
+                "name": "test_server",
+                "status": "BUILD",
+                "hostId": '',
+                "image": {
+                    "id": "5",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": image_bookmark,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                    "links": [
+                                              {
+                            "rel": "bookmark",
+                            "href": flavor_bookmark,
+                        },
+                    ],
+                },
+                "addresses": {},
+                "metadata": {},
+                "accessIPv4": "",
+                "accessIPv6": "fead::1234",
+                "links": [
+                    {
+                        "rel": "self",
+                        "href": "http://localhost/v1.1/servers/1",
+                    },
+                    {
+                        "rel": "bookmark",
+                        "href": "http://localhost/servers/1",
+                    },
+                ],
+            }
+        }
+
+        output = self.view_builder.build(self.instance, True)
+        self.assertDictMatch(output, expected_server)
+
     def test_build_server_detail_with_metadata(self):
 
         metadata = []
@@ -3199,6 +3500,8 @@ class ServersViewBuilderV11Test(test.TestCase):
                 "progress": 0,
                 "name": "test_server",
                 "status": "BUILD",
+                "accessIPv4": "",
+                "accessIPv6": "",
                 "hostId": '',
                 "image": {
                     "id": "5",
@@ -3265,6 +3568,8 @@ class ServerXMLSerializationTest(test.TestCase):
                 "name": "test_server",
                 "status": "BUILD",
                 "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
+                "accessIPv4": "1.2.3.4",
+                "accessIPv6": "fead::1234",
                 "image": {
                     "id": "5",
                     "links": [
@@ -3323,7 +3628,9 @@ class ServerXMLSerializationTest(test.TestCase):
         }
 
         output = serializer.serialize(fixture, 'show')
-        actual = minidom.parseString(output.replace("  ", ""))
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'server')
 
         expected_server_href = self.SERVER_HREF
         expected_server_bookmark = self.SERVER_BOOKMARK
@@ -3331,47 +3638,57 @@ class ServerXMLSerializationTest(test.TestCase):
         expected_flavor_bookmark = self.FLAVOR_BOOKMARK
         expected_now = self.TIMESTAMP
         expected_uuid = FAKE_UUID
-        expected = minidom.parseString("""
-        <server id="1"
-                uuid="%(expected_uuid)s"
-                xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                name="test_server"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
-                status="BUILD"
-                progress="0">
-            <atom:link href="%(expected_server_href)s" rel="self"/>
-            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
-            <image id="5">
-                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
-            </image>
-            <flavor id="1">
-                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
-            </flavor>
-            <metadata>
-                <meta key="Open">
-                    Stack
-                </meta>
-                <meta key="Number">
-                    1
-                </meta>
-            </metadata>
-            <addresses>
-                <network id="network_one">
-                    <ip version="4" addr="67.23.10.138"/>
-                    <ip version="6" addr="::babe:67.23.10.138"/>
-                </network>
-                <network id="network_two">
-                    <ip version="4" addr="67.23.10.139"/>
-                    <ip version="6" addr="::babe:67.23.10.139"/>
-                </network>
-            </addresses>
-        </server>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        server_dict = fixture['server']
+
+        for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
+                    'updated', 'progress', 'status', 'hostId',
+                    'accessIPv6']:
+            self.assertEqual(root.get(key), str(server_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(server_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        metadata_root = root.find('{0}metadata'.format(NS))
+        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 2)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = server_dict['metadata'].items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
+
+        image_root = root.find('{0}image'.format(NS))
+        self.assertEqual(image_root.get('id'), server_dict['image']['id'])
+        link_nodes = image_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 1)
+        for i, link in enumerate(server_dict['image']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        flavor_root = root.find('{0}flavor'.format(NS))
+        self.assertEqual(flavor_root.get('id'), server_dict['flavor']['id'])
+        link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 1)
+        for i, link in enumerate(server_dict['flavor']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        addresses_root = root.find('{0}addresses'.format(NS))
+        addresses_dict = server_dict['addresses']
+        network_elems = addresses_root.findall('{0}network'.format(NS))
+        self.assertEqual(len(network_elems), 2)
+        for i, network_elem in enumerate(network_elems):
+            network = addresses_dict.items()[i]
+            self.assertEqual(str(network_elem.get('id')), str(network[0]))
+            ip_elems = network_elem.findall('{0}ip'.format(NS))
+            for z, ip_elem in enumerate(ip_elems):
+                ip = network[1][z]
+                self.assertEqual(str(ip_elem.get('version')),
+                                 str(ip['version']))
+                self.assertEqual(str(ip_elem.get('addr')),
+                                 str(ip['addr']))
 
     def test_create(self):
         serializer = servers.ServerXMLSerializer()
@@ -3385,6 +3702,8 @@ class ServerXMLSerializationTest(test.TestCase):
                 "progress": 0,
                 "name": "test_server",
                 "status": "BUILD",
+                "accessIPv4": "1.2.3.4",
+                "accessIPv6": "fead::1234",
                 "hostId": "e4d909c290d0fb1ca068ffaddf22cbd0",
                 "adminPass": "test_password",
                 "image": {
@@ -3445,7 +3764,9 @@ class ServerXMLSerializationTest(test.TestCase):
         }
 
         output = serializer.serialize(fixture, 'create')
-        actual = minidom.parseString(output.replace("  ", ""))
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'server')
 
         expected_server_href = self.SERVER_HREF
         expected_server_bookmark = self.SERVER_BOOKMARK
@@ -3453,48 +3774,57 @@ class ServerXMLSerializationTest(test.TestCase):
         expected_flavor_bookmark = self.FLAVOR_BOOKMARK
         expected_now = self.TIMESTAMP
         expected_uuid = FAKE_UUID
-        expected = minidom.parseString("""
-        <server id="1"
-                uuid="%(expected_uuid)s"
-                xmlns="http://docs.openstack.org/compute/api/v1.1"
-                xmlns:atom="http://www.w3.org/2005/Atom"
-                name="test_server"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
-                status="BUILD"
-                adminPass="test_password"
-                progress="0">
-            <atom:link href="%(expected_server_href)s" rel="self"/>
-            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
-            <image id="5">
-                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
-            </image>
-            <flavor id="1">
-                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
-            </flavor>
-            <metadata>
-                <meta key="Open">
-                    Stack
-                </meta>
-                <meta key="Number">
-                    1
-                </meta>
-            </metadata>
-            <addresses>
-                <network id="network_one">
-                    <ip version="4" addr="67.23.10.138"/>
-                    <ip version="6" addr="::babe:67.23.10.138"/>
-                </network>
-                <network id="network_two">
-                    <ip version="4" addr="67.23.10.139"/>
-                    <ip version="6" addr="::babe:67.23.10.139"/>
-                </network>
-            </addresses>
-        </server>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        server_dict = fixture['server']
+
+        for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
+                    'updated', 'progress', 'status', 'hostId',
+                    'accessIPv6', 'adminPass']:
+            self.assertEqual(root.get(key), str(server_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(server_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        metadata_root = root.find('{0}metadata'.format(NS))
+        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 2)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = server_dict['metadata'].items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
+
+        image_root = root.find('{0}image'.format(NS))
+        self.assertEqual(image_root.get('id'), server_dict['image']['id'])
+        link_nodes = image_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 1)
+        for i, link in enumerate(server_dict['image']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        flavor_root = root.find('{0}flavor'.format(NS))
+        self.assertEqual(flavor_root.get('id'), server_dict['flavor']['id'])
+        link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 1)
+        for i, link in enumerate(server_dict['flavor']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        addresses_root = root.find('{0}addresses'.format(NS))
+        addresses_dict = server_dict['addresses']
+        network_elems = addresses_root.findall('{0}network'.format(NS))
+        self.assertEqual(len(network_elems), 2)
+        for i, network_elem in enumerate(network_elems):
+            network = addresses_dict.items()[i]
+            self.assertEqual(str(network_elem.get('id')), str(network[0]))
+            ip_elems = network_elem.findall('{0}ip'.format(NS))
+            for z, ip_elem in enumerate(ip_elems):
+                ip = network[1][z]
+                self.assertEqual(str(ip_elem.get('version')),
+                                 str(ip['version']))
+                self.assertEqual(str(ip_elem.get('addr')),
+                                 str(ip['addr']))
 
     def test_index(self):
         serializer = servers.ServerXMLSerializer()
@@ -3535,23 +3865,21 @@ class ServerXMLSerializationTest(test.TestCase):
         ]}
 
         output = serializer.serialize(fixture, 'index')
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-        <servers xmlns="http://docs.openstack.org/compute/api/v1.1"
-                 xmlns:atom="http://www.w3.org/2005/Atom">
-        <server id="1" name="test_server">
-            <atom:link href="%(expected_server_href)s" rel="self"/>
-            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
-        </server>
-        <server id="2" name="test_server_2">
-            <atom:link href="%(expected_server_href_2)s" rel="self"/>
-            <atom:link href="%(expected_server_bookmark_2)s" rel="bookmark"/>
-        </server>
-        </servers>
-        """.replace("  ", "") % (locals()))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'servers_index')
+        server_elems = root.findall('{0}server'.format(NS))
+        self.assertEqual(len(server_elems), 2)
+        for i, server_elem in enumerate(server_elems):
+            server_dict = fixture['servers'][i]
+            for key in ['name', 'id']:
+                self.assertEqual(server_elem.get(key), str(server_dict[key]))
+
+            link_nodes = server_elem.findall('{0}link'.format(ATOMNS))
+            self.assertEqual(len(link_nodes), 2)
+            for i, link in enumerate(server_dict['links']):
+                for key, value in link.items():
+                    self.assertEqual(link_nodes[i].get(key), value)
 
     def test_detail(self):
         serializer = servers.ServerXMLSerializer()
@@ -3574,6 +3902,8 @@ class ServerXMLSerializationTest(test.TestCase):
                 "progress": 0,
                 "name": "test_server",
                 "status": "BUILD",
+                "accessIPv4": "1.2.3.4",
+                "accessIPv6": "fead::1234",
                 "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
                 "image": {
                     "id": "5",
@@ -3627,6 +3957,8 @@ class ServerXMLSerializationTest(test.TestCase):
                 "progress": 100,
                 "name": "test_server_2",
                 "status": "ACTIVE",
+                "accessIPv4": "1.2.3.4",
+                "accessIPv6": "fead::1234",
                 "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
                 "image": {
                     "id": "5",
@@ -3675,68 +4007,195 @@ class ServerXMLSerializationTest(test.TestCase):
         ]}
 
         output = serializer.serialize(fixture, 'detail')
-        actual = minidom.parseString(output.replace("  ", ""))
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'servers')
+        server_elems = root.findall('{0}server'.format(NS))
+        self.assertEqual(len(server_elems), 2)
+        for i, server_elem in enumerate(server_elems):
+            server_dict = fixture['servers'][i]
+
+            for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
+                        'updated', 'progress', 'status', 'hostId',
+                        'accessIPv6']:
+                self.assertEqual(server_elem.get(key), str(server_dict[key]))
+
+            link_nodes = server_elem.findall('{0}link'.format(ATOMNS))
+            self.assertEqual(len(link_nodes), 2)
+            for i, link in enumerate(server_dict['links']):
+                for key, value in link.items():
+                    self.assertEqual(link_nodes[i].get(key), value)
+
+            metadata_root = server_elem.find('{0}metadata'.format(NS))
+            metadata_elems = metadata_root.findall('{0}meta'.format(NS))
+            for i, metadata_elem in enumerate(metadata_elems):
+                (meta_key, meta_value) = server_dict['metadata'].items()[i]
+                self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+                self.assertEqual(str(metadata_elem.text).strip(),
+                                 str(meta_value))
+
+            image_root = server_elem.find('{0}image'.format(NS))
+            self.assertEqual(image_root.get('id'), server_dict['image']['id'])
+            link_nodes = image_root.findall('{0}link'.format(ATOMNS))
+            self.assertEqual(len(link_nodes), 1)
+            for i, link in enumerate(server_dict['image']['links']):
+                for key, value in link.items():
+                    self.assertEqual(link_nodes[i].get(key), value)
+
+            flavor_root = server_elem.find('{0}flavor'.format(NS))
+            self.assertEqual(flavor_root.get('id'),
+                             server_dict['flavor']['id'])
+            link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
+            self.assertEqual(len(link_nodes), 1)
+            for i, link in enumerate(server_dict['flavor']['links']):
+                for key, value in link.items():
+                    self.assertEqual(link_nodes[i].get(key), value)
+
+            addresses_root = server_elem.find('{0}addresses'.format(NS))
+            addresses_dict = server_dict['addresses']
+            network_elems = addresses_root.findall('{0}network'.format(NS))
+            for i, network_elem in enumerate(network_elems):
+                network = addresses_dict.items()[i]
+                self.assertEqual(str(network_elem.get('id')), str(network[0]))
+                ip_elems = network_elem.findall('{0}ip'.format(NS))
+                for z, ip_elem in enumerate(ip_elems):
+                    ip = network[1][z]
+                    self.assertEqual(str(ip_elem.get('version')),
+                                     str(ip['version']))
+                    self.assertEqual(str(ip_elem.get('addr')),
+                                     str(ip['addr']))
+
+    def test_update(self):
+        serializer = servers.ServerXMLSerializer()
 
-        expected = minidom.parseString("""
-        <servers xmlns="http://docs.openstack.org/compute/api/v1.1"
-                 xmlns:atom="http://www.w3.org/2005/Atom">
-        <server id="1"
-                uuid="%(expected_uuid)s"
-                name="test_server"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
-                status="BUILD"
-                progress="0">
-            <atom:link href="%(expected_server_href)s" rel="self"/>
-            <atom:link href="%(expected_server_bookmark)s" rel="bookmark"/>
-            <image id="5">
-                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
-            </image>
-            <flavor id="1">
-                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
-            </flavor>
-            <metadata>
-                <meta key="Number">
-                    1
-                </meta>
-            </metadata>
-            <addresses>
-                <network id="network_one">
-                    <ip version="4" addr="67.23.10.138"/>
-                    <ip version="6" addr="::babe:67.23.10.138"/>
-                </network>
-            </addresses>
-        </server>
-        <server id="2"
-                uuid="%(expected_uuid)s"
-                name="test_server_2"
-                updated="%(expected_now)s"
-                created="%(expected_now)s"
-                hostId="e4d909c290d0fb1ca068ffaddf22cbd0"
-                status="ACTIVE"
-                progress="100">
-            <atom:link href="%(expected_server_href_2)s" rel="self"/>
-            <atom:link href="%(expected_server_bookmark_2)s" rel="bookmark"/>
-            <image id="5">
-                <atom:link rel="bookmark" href="%(expected_image_bookmark)s"/>
-            </image>
-            <flavor id="1">
-                <atom:link rel="bookmark" href="%(expected_flavor_bookmark)s"/>
-            </flavor>
-            <metadata>
-                <meta key="Number">
-                    2
-                </meta>
-            </metadata>
-            <addresses>
-                <network id="network_one">
-                    <ip version="4" addr="67.23.10.138"/>
-                    <ip version="6" addr="::babe:67.23.10.138"/>
-                </network>
-            </addresses>
-        </server>
-        </servers>
-        """.replace("  ", "") % (locals()))
+        fixture = {
+            "server": {
+                "id": 1,
+                "uuid": FAKE_UUID,
+                'created': self.TIMESTAMP,
+                'updated': self.TIMESTAMP,
+                "progress": 0,
+                "name": "test_server",
+                "status": "BUILD",
+                "hostId": 'e4d909c290d0fb1ca068ffaddf22cbd0',
+                "accessIPv4": "1.2.3.4",
+                "accessIPv6": "fead::1234",
+                "image": {
+                    "id": "5",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": self.IMAGE_BOOKMARK,
+                        },
+                    ],
+                },
+                "flavor": {
+                    "id": "1",
+                    "links": [
+                        {
+                            "rel": "bookmark",
+                            "href": self.FLAVOR_BOOKMARK,
+                        },
+                    ],
+                },
+                "addresses": {
+                    "network_one": [
+                        {
+                            "version": 4,
+                            "addr": "67.23.10.138",
+                        },
+                        {
+                            "version": 6,
+                            "addr": "::babe:67.23.10.138",
+                        },
+                    ],
+                    "network_two": [
+                        {
+                            "version": 4,
+                            "addr": "67.23.10.139",
+                        },
+                        {
+                            "version": 6,
+                            "addr": "::babe:67.23.10.139",
+                        },
+                    ],
+                },
+                "metadata": {
+                    "Open": "Stack",
+                    "Number": "1",
+                },
+                'links': [
+                    {
+                        'href': self.SERVER_HREF,
+                        'rel': 'self',
+                    },
+                    {
+                        'href': self.SERVER_BOOKMARK,
+                        'rel': 'bookmark',
+                    },
+                ],
+            }
+        }
 
-        self.assertEqual(expected.toxml(), actual.toxml())
+        output = serializer.serialize(fixture, 'update')
+        print output
+        root = etree.XML(output)
+        xmlutil.validate_schema(root, 'server')
+
+        expected_server_href = self.SERVER_HREF
+        expected_server_bookmark = self.SERVER_BOOKMARK
+        expected_image_bookmark = self.IMAGE_BOOKMARK
+        expected_flavor_bookmark = self.FLAVOR_BOOKMARK
+        expected_now = self.TIMESTAMP
+        expected_uuid = FAKE_UUID
+        server_dict = fixture['server']
+
+        for key in ['name', 'id', 'uuid', 'created', 'accessIPv4',
+                    'updated', 'progress', 'status', 'hostId',
+                    'accessIPv6']:
+            self.assertEqual(root.get(key), str(server_dict[key]))
+
+        link_nodes = root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 2)
+        for i, link in enumerate(server_dict['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        metadata_root = root.find('{0}metadata'.format(NS))
+        metadata_elems = metadata_root.findall('{0}meta'.format(NS))
+        self.assertEqual(len(metadata_elems), 2)
+        for i, metadata_elem in enumerate(metadata_elems):
+            (meta_key, meta_value) = server_dict['metadata'].items()[i]
+            self.assertEqual(str(metadata_elem.get('key')), str(meta_key))
+            self.assertEqual(str(metadata_elem.text).strip(), str(meta_value))
+
+        image_root = root.find('{0}image'.format(NS))
+        self.assertEqual(image_root.get('id'), server_dict['image']['id'])
+        link_nodes = image_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 1)
+        for i, link in enumerate(server_dict['image']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        flavor_root = root.find('{0}flavor'.format(NS))
+        self.assertEqual(flavor_root.get('id'), server_dict['flavor']['id'])
+        link_nodes = flavor_root.findall('{0}link'.format(ATOMNS))
+        self.assertEqual(len(link_nodes), 1)
+        for i, link in enumerate(server_dict['flavor']['links']):
+            for key, value in link.items():
+                self.assertEqual(link_nodes[i].get(key), value)
+
+        addresses_root = root.find('{0}addresses'.format(NS))
+        addresses_dict = server_dict['addresses']
+        network_elems = addresses_root.findall('{0}network'.format(NS))
+        self.assertEqual(len(network_elems), 2)
+        for i, network_elem in enumerate(network_elems):
+            network = addresses_dict.items()[i]
+            self.assertEqual(str(network_elem.get('id')), str(network[0]))
+            ip_elems = network_elem.findall('{0}ip'.format(NS))
+            for z, ip_elem in enumerate(ip_elems):
+                ip = network[1][z]
+                self.assertEqual(str(ip_elem.get('version')),
+                                 str(ip['version']))
+                self.assertEqual(str(ip_elem.get('addr')),
+                                 str(ip['addr']))
diff --git a/nova/tests/integrated/test_servers.py b/nova/tests/integrated/test_servers.py
index 150279a95..725f6d529 100644
--- a/nova/tests/integrated/test_servers.py
+++ b/nova/tests/integrated/test_servers.py
@@ -27,6 +27,7 @@ LOG = logging.getLogger('nova.tests.integrated')
 
 
 class ServersTest(integrated_helpers._IntegratedTestBase):
+
     def test_get_servers(self):
         """Simple check that listing servers works."""
         servers = self.api.get_servers()
@@ -103,6 +104,10 @@ class ServersTest(integrated_helpers._IntegratedTestBase):
         # It should be available...
         # TODO(justinsb): Mock doesn't yet do this...
         #self.assertEqual('available', found_server['status'])
+        servers = self.api.get_servers(detail=True)
+        for server in servers:
+            self.assertTrue("image" in server)
+            self.assertTrue("flavor" in server)
 
         self._delete_server(created_server_id)
 
diff --git a/nova/tests/scheduler/test_abstract_scheduler.py b/nova/tests/scheduler/test_abstract_scheduler.py
index f4f5cc233..aa97e2344 100644
--- a/nova/tests/scheduler/test_abstract_scheduler.py
+++ b/nova/tests/scheduler/test_abstract_scheduler.py
@@ -77,6 +77,9 @@ class FakeZoneManager(zone_manager.ZoneManager):
             'host3': {
                 'compute': {'host_memory_free': 3221225472},
             },
+            'host4': {
+                'compute': {'host_memory_free': 999999999},
+            },
         }
 
 
diff --git a/nova/tests/scheduler/test_host_filter.py b/nova/tests/scheduler/test_host_filter.py
index 7e664d3f9..17431fc7e 100644
--- a/nova/tests/scheduler/test_host_filter.py
+++ b/nova/tests/scheduler/test_host_filter.py
@@ -21,6 +21,7 @@ import json
 from nova import exception
 from nova import test
 from nova.scheduler import host_filter
+from nova.scheduler import filters
 
 
 class FakeZoneManager:
@@ -55,7 +56,7 @@ class HostFilterTestCase(test.TestCase):
 
     def setUp(self):
         super(HostFilterTestCase, self).setUp()
-        default_host_filter = 'nova.scheduler.host_filter.AllHostsFilter'
+        default_host_filter = 'AllHostsFilter'
         self.flags(default_host_filter=default_host_filter)
         self.instance_type = dict(name='tiny',
                 memory_mb=50,
@@ -98,13 +99,10 @@ class HostFilterTestCase(test.TestCase):
     def test_choose_filter(self):
         # Test default filter ...
         hf = host_filter.choose_host_filter()
-        self.assertEquals(hf._full_name(),
-                        'nova.scheduler.host_filter.AllHostsFilter')
+        self.assertEquals(hf._full_name().split(".")[-1], 'AllHostsFilter')
         # Test valid filter ...
-        hf = host_filter.choose_host_filter(
-                        'nova.scheduler.host_filter.InstanceTypeFilter')
-        self.assertEquals(hf._full_name(),
-                        'nova.scheduler.host_filter.InstanceTypeFilter')
+        hf = host_filter.choose_host_filter('InstanceTypeFilter')
+        self.assertEquals(hf._full_name().split(".")[-1], 'InstanceTypeFilter')
         # Test invalid filter ...
         try:
             host_filter.choose_host_filter('does not exist')
@@ -113,7 +111,7 @@ class HostFilterTestCase(test.TestCase):
             pass
 
     def test_all_host_filter(self):
-        hf = host_filter.AllHostsFilter()
+        hf = filters.AllHostsFilter()
         cooked = hf.instance_type_to_filter(self.instance_type)
         hosts = hf.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(10, len(hosts))
@@ -121,11 +119,10 @@ class HostFilterTestCase(test.TestCase):
             self.assertTrue(host.startswith('host'))
 
     def test_instance_type_filter(self):
-        hf = host_filter.InstanceTypeFilter()
+        hf = filters.InstanceTypeFilter()
         # filter all hosts that can support 50 ram and 500 disk
         name, cooked = hf.instance_type_to_filter(self.instance_type)
-        self.assertEquals('nova.scheduler.host_filter.InstanceTypeFilter',
-                          name)
+        self.assertEquals(name.split(".")[-1], 'InstanceTypeFilter')
         hosts = hf.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(6, len(hosts))
         just_hosts = [host for host, caps in hosts]
@@ -134,21 +131,20 @@ class HostFilterTestCase(test.TestCase):
         self.assertEquals('host10', just_hosts[5])
 
     def test_instance_type_filter_extra_specs(self):
-        hf = host_filter.InstanceTypeFilter()
+        hf = filters.InstanceTypeFilter()
         # filter all hosts that can support 50 ram and 500 disk
         name, cooked = hf.instance_type_to_filter(self.gpu_instance_type)
-        self.assertEquals('nova.scheduler.host_filter.InstanceTypeFilter',
-                          name)
+        self.assertEquals(name.split(".")[-1], 'InstanceTypeFilter')
         hosts = hf.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(1, len(hosts))
         just_hosts = [host for host, caps in hosts]
         self.assertEquals('host07', just_hosts[0])
 
     def test_json_filter(self):
-        hf = host_filter.JsonFilter()
+        hf = filters.JsonFilter()
         # filter all hosts that can support 50 ram and 500 disk
         name, cooked = hf.instance_type_to_filter(self.instance_type)
-        self.assertEquals('nova.scheduler.host_filter.JsonFilter', name)
+        self.assertEquals(name.split(".")[-1], 'JsonFilter')
         hosts = hf.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(6, len(hosts))
         just_hosts = [host for host, caps in hosts]
@@ -192,7 +188,6 @@ class HostFilterTestCase(test.TestCase):
         raw = ['in', '$compute.host_memory_free', 20, 40, 60, 80, 100]
         cooked = json.dumps(raw)
         hosts = hf.filter_hosts(self.zone_manager, cooked)
-
         self.assertEquals(5, len(hosts))
         just_hosts = [host for host, caps in hosts]
         just_hosts.sort()
diff --git a/nova/tests/scheduler/test_least_cost_scheduler.py b/nova/tests/scheduler/test_least_cost_scheduler.py
index de7581d0a..af58de527 100644
--- a/nova/tests/scheduler/test_least_cost_scheduler.py
+++ b/nova/tests/scheduler/test_least_cost_scheduler.py
@@ -15,6 +15,7 @@
 """
 Tests For Least Cost Scheduler
 """
+import copy
 
 from nova import test
 from nova.scheduler import least_cost
@@ -81,7 +82,7 @@ class LeastCostSchedulerTestCase(test.TestCase):
         super(LeastCostSchedulerTestCase, self).tearDown()
 
     def assertWeights(self, expected, num, request_spec, hosts):
-        weighted = self.sched.weigh_hosts(num, request_spec, hosts)
+        weighted = self.sched.weigh_hosts("compute", request_spec, hosts)
         self.assertDictListMatch(weighted, expected, approx_equal=True)
 
     def test_no_hosts(self):
@@ -122,19 +123,24 @@ class LeastCostSchedulerTestCase(test.TestCase):
         self.flags(least_cost_scheduler_cost_functions=[
                 'nova.scheduler.least_cost.compute_fill_first_cost_fn'],
                 compute_fill_first_cost_fn_weight=1)
-
         num = 1
         instance_type = {'memory_mb': 1024}
         request_spec = {'instance_type': instance_type}
-        hosts = self.sched.filter_hosts('compute', request_spec, None)
+        svc_states = self.sched.zone_manager.service_states.iteritems()
+        all_hosts = [(host, services["compute"])
+                for host, services in svc_states
+                if "compute" in services]
+        hosts = self.sched.filter_hosts('compute', request_spec, all_hosts)
 
         expected = []
-        for idx, (hostname, caps) in enumerate(hosts):
+        for idx, (hostname, services) in enumerate(hosts):
+            caps = copy.deepcopy(services["compute"])
             # Costs are normalized so over 10 hosts, each host with increasing
             # free ram will cost 1/N more. Since the lowest cost host has some
             # free ram, we add in the 1/N for the base_cost
             weight = 0.1 + (0.1 * idx)
-            weight_dict = dict(weight=weight, hostname=hostname)
-            expected.append(weight_dict)
+            wtd_dict = dict(hostname=hostname, weight=weight,
+                    capabilities=caps)
+            expected.append(wtd_dict)
 
         self.assertWeights(expected, num, request_spec, hosts)
diff --git a/nova/tests/test_api.py b/nova/tests/test_api.py
index 2011ae756..526d1c490 100644
--- a/nova/tests/test_api.py
+++ b/nova/tests/test_api.py
@@ -32,6 +32,7 @@ from nova import context
 from nova import exception
 from nova import test
 from nova import wsgi
+from nova.api import auth
 from nova.api import ec2
 from nova.api.ec2 import apirequest
 from nova.api.ec2 import cloud
@@ -199,7 +200,7 @@ class ApiEc2TestCase(test.TestCase):
         # NOTE(vish): skipping the Authorizer
         roles = ['sysadmin', 'netadmin']
         ctxt = context.RequestContext('fake', 'fake', roles=roles)
-        self.app = wsgi.InjectContext(ctxt,
+        self.app = auth.InjectContext(ctxt,
                 ec2.Requestify(ec2.Authorizer(ec2.Executor()),
                                'nova.api.ec2.cloud.CloudController'))
 
diff --git a/nova/tests/test_cloud.py b/nova/tests/test_cloud.py
index b2afc53c9..0793784f8 100644
--- a/nova/tests/test_cloud.py
+++ b/nova/tests/test_cloud.py
@@ -487,6 +487,17 @@ class CloudTestCase(test.TestCase):
         db.service_destroy(self.context, comp1['id'])
         db.service_destroy(self.context, comp2['id'])
 
+    def test_describe_instances_deleted(self):
+        args1 = {'reservation_id': 'a', 'image_ref': 1, 'host': 'host1'}
+        inst1 = db.instance_create(self.context, args1)
+        args2 = {'reservation_id': 'b', 'image_ref': 1, 'host': 'host1'}
+        inst2 = db.instance_create(self.context, args2)
+        db.instance_destroy(self.context, inst1.id)
+        result = self.cloud.describe_instances(self.context)
+        result = result['reservationSet'][0]['instancesSet']
+        self.assertEqual(result[0]['instanceId'],
+                         ec2utils.id_to_ec2_id(inst2.id))
+
     def _block_device_mapping_create(self, instance_id, mappings):
         volumes = []
         for bdm in mappings:
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index e2fa3b140..4f5d36f14 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -1341,6 +1341,69 @@ class ComputeTestCase(test.TestCase):
         db.instance_destroy(c, instance_id2)
         db.instance_destroy(c, instance_id3)
 
+    def test_get_all_by_metadata(self):
+        """Test searching instances by metadata"""
+
+        c = context.get_admin_context()
+        instance_id0 = self._create_instance()
+        instance_id1 = self._create_instance({
+                'metadata': {'key1': 'value1'}})
+        instance_id2 = self._create_instance({
+                'metadata': {'key2': 'value2'}})
+        instance_id3 = self._create_instance({
+                'metadata': {'key3': 'value3'}})
+        instance_id4 = self._create_instance({
+                'metadata': {'key3': 'value3',
+                             'key4': 'value4'}})
+
+        # get all instances
+        instances = self.compute_api.get_all(c,
+                search_opts={'metadata': {}})
+        self.assertEqual(len(instances), 5)
+
+        # wrong key/value combination
+        instances = self.compute_api.get_all(c,
+                search_opts={'metadata': {'key1': 'value3'}})
+        self.assertEqual(len(instances), 0)
+
+        # non-existing keys
+        instances = self.compute_api.get_all(c,
+                search_opts={'metadata': {'key5': 'value1'}})
+        self.assertEqual(len(instances), 0)
+
+        # find existing instance
+        instances = self.compute_api.get_all(c,
+                search_opts={'metadata': {'key2': 'value2'}})
+        self.assertEqual(len(instances), 1)
+        self.assertEqual(instances[0].id, instance_id2)
+
+        instances = self.compute_api.get_all(c,
+                search_opts={'metadata': {'key3': 'value3'}})
+        self.assertEqual(len(instances), 2)
+        instance_ids = [instance.id for instance in instances]
+        self.assertTrue(instance_id3 in instance_ids)
+        self.assertTrue(instance_id4 in instance_ids)
+
+        # multiple criterias as a dict
+        instances = self.compute_api.get_all(c,
+                search_opts={'metadata': {'key3': 'value3',
+                                          'key4': 'value4'}})
+        self.assertEqual(len(instances), 1)
+        self.assertEqual(instances[0].id, instance_id4)
+
+        # multiple criterias as a list
+        instances = self.compute_api.get_all(c,
+                search_opts={'metadata': [{'key4': 'value4'},
+                                          {'key3': 'value3'}]})
+        self.assertEqual(len(instances), 1)
+        self.assertEqual(instances[0].id, instance_id4)
+
+        db.instance_destroy(c, instance_id0)
+        db.instance_destroy(c, instance_id1)
+        db.instance_destroy(c, instance_id2)
+        db.instance_destroy(c, instance_id3)
+        db.instance_destroy(c, instance_id4)
+
     @staticmethod
     def _parse_db_block_device_mapping(bdm_ref):
         attr_list = ('delete_on_termination', 'device_name', 'no_device',
diff --git a/nova/tests/test_db_api.py b/nova/tests/test_db_api.py
index 0c07cbb7c..038c07f40 100644
--- a/nova/tests/test_db_api.py
+++ b/nova/tests/test_db_api.py
@@ -76,3 +76,20 @@ class DbApiTestCase(test.TestCase):
         self.assertEqual(instance['id'], result['id'])
         self.assertEqual(result['fixed_ips'][0]['floating_ips'][0].address,
                          '1.2.1.2')
+
+    def test_instance_get_all_by_filters(self):
+        args = {'reservation_id': 'a', 'image_ref': 1, 'host': 'host1'}
+        inst1 = db.instance_create(self.context, args)
+        inst2 = db.instance_create(self.context, args)
+        result = db.instance_get_all_by_filters(self.context, {})
+        self.assertTrue(2, len(result))
+
+    def test_instance_get_all_by_filters_deleted(self):
+        args1 = {'reservation_id': 'a', 'image_ref': 1, 'host': 'host1'}
+        inst1 = db.instance_create(self.context, args1)
+        args2 = {'reservation_id': 'b', 'image_ref': 1, 'host': 'host1'}
+        inst2 = db.instance_create(self.context, args2)
+        db.instance_destroy(self.context, inst1.id)
+        result = db.instance_get_all_by_filters(self.context.elevated(), {})
+        self.assertEqual(1, len(result))
+        self.assertEqual(result[0].id, inst2.id)
diff --git a/nova/tests/test_host_filter.py b/nova/tests/test_host_filter.py
deleted file mode 100644
index 3a1389a49..000000000
--- a/nova/tests/test_host_filter.py
+++ /dev/null
@@ -1,200 +0,0 @@
-# Copyright 2011 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.
-"""
-Tests For Scheduler Host Filters.
-"""
-
-import json
-
-from nova import exception
-from nova import test
-from nova.scheduler import host_filter
-
-
-class FakeZoneManager:
-    pass
-
-
-class HostFilterTestCase(test.TestCase):
-    """Test case for host filters."""
-
-    def _host_caps(self, multiplier):
-        # Returns host capabilities in the following way:
-        # host1 = memory:free 10 (100max)
-        #         disk:available 100 (1000max)
-        # hostN = memory:free 10 + 10N
-        #         disk:available 100 + 100N
-        # in other words: hostN has more resources than host0
-        # which means ... don't go above 10 hosts.
-        return {'host_name-description': 'XenServer %s' % multiplier,
-                'host_hostname': 'xs-%s' % multiplier,
-                'host_memory_total': 100,
-                'host_memory_overhead': 10,
-                'host_memory_free': 10 + multiplier * 10,
-                'host_memory_free-computed': 10 + multiplier * 10,
-                'host_other-config': {},
-                'host_ip_address': '192.168.1.%d' % (100 + multiplier),
-                'host_cpu_info': {},
-                'disk_available': 100 + multiplier * 100,
-                'disk_total': 1000,
-                'disk_used': 0,
-                'host_uuid': 'xxx-%d' % multiplier,
-                'host_name-label': 'xs-%s' % multiplier}
-
-    def setUp(self):
-        super(HostFilterTestCase, self).setUp()
-        default_host_filter = 'nova.scheduler.host_filter.AllHostsFilter'
-        self.flags(default_host_filter=default_host_filter)
-        self.instance_type = dict(name='tiny',
-                memory_mb=50,
-                vcpus=10,
-                local_gb=500,
-                flavorid=1,
-                swap=500,
-                rxtx_quota=30000,
-                rxtx_cap=200,
-                extra_specs={})
-
-        self.zone_manager = FakeZoneManager()
-        states = {}
-        for x in xrange(10):
-            states['host%02d' % (x + 1)] = {'compute': self._host_caps(x)}
-        self.zone_manager.service_states = states
-
-    def test_choose_filter(self):
-        # Test default filter ...
-        hf = host_filter.choose_host_filter()
-        self.assertEquals(hf._full_name(),
-                        'nova.scheduler.host_filter.AllHostsFilter')
-        # Test valid filter ...
-        hf = host_filter.choose_host_filter(
-                        'nova.scheduler.host_filter.InstanceTypeFilter')
-        self.assertEquals(hf._full_name(),
-                        'nova.scheduler.host_filter.InstanceTypeFilter')
-        # Test invalid filter ...
-        try:
-            host_filter.choose_host_filter('does not exist')
-            self.fail("Should not find host filter.")
-        except exception.SchedulerHostFilterNotFound:
-            pass
-
-    def test_all_host_filter(self):
-        hf = host_filter.AllHostsFilter()
-        cooked = hf.instance_type_to_filter(self.instance_type)
-        hosts = hf.filter_hosts(self.zone_manager, cooked)
-        self.assertEquals(10, len(hosts))
-        for host, capabilities in hosts:
-            self.assertTrue(host.startswith('host'))
-
-    def test_instance_type_filter(self):
-        hf = host_filter.InstanceTypeFilter()
-        # filter all hosts that can support 50 ram and 500 disk
-        name, cooked = hf.instance_type_to_filter(self.instance_type)
-        self.assertEquals('nova.scheduler.host_filter.InstanceTypeFilter',
-                          name)
-        hosts = hf.filter_hosts(self.zone_manager, cooked)
-        self.assertEquals(6, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        self.assertEquals('host05', just_hosts[0])
-        self.assertEquals('host10', just_hosts[5])
-
-    def test_json_filter(self):
-        hf = host_filter.JsonFilter()
-        # filter all hosts that can support 50 ram and 500 disk
-        name, cooked = hf.instance_type_to_filter(self.instance_type)
-        self.assertEquals('nova.scheduler.host_filter.JsonFilter', name)
-        hosts = hf.filter_hosts(self.zone_manager, cooked)
-        self.assertEquals(6, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        self.assertEquals('host05', just_hosts[0])
-        self.assertEquals('host10', just_hosts[5])
-
-        # Try some custom queries
-
-        raw = ['or',
-                   ['and',
-                       ['<', '$compute.host_memory_free', 30],
-                       ['<', '$compute.disk_available', 300],
-                   ],
-                   ['and',
-                       ['>', '$compute.host_memory_free', 70],
-                       ['>', '$compute.disk_available', 700],
-                   ],
-              ]
-
-        cooked = json.dumps(raw)
-        hosts = hf.filter_hosts(self.zone_manager, cooked)
-
-        self.assertEquals(5, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        for index, host in zip([1, 2, 8, 9, 10], just_hosts):
-            self.assertEquals('host%02d' % index, host)
-
-        raw = ['not',
-                  ['=', '$compute.host_memory_free', 30],
-              ]
-        cooked = json.dumps(raw)
-        hosts = hf.filter_hosts(self.zone_manager, cooked)
-
-        self.assertEquals(9, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        for index, host in zip([1, 2, 4, 5, 6, 7, 8, 9, 10], just_hosts):
-            self.assertEquals('host%02d' % index, host)
-
-        raw = ['in', '$compute.host_memory_free', 20, 40, 60, 80, 100]
-        cooked = json.dumps(raw)
-        hosts = hf.filter_hosts(self.zone_manager, cooked)
-
-        self.assertEquals(5, len(hosts))
-        just_hosts = [host for host, caps in hosts]
-        just_hosts.sort()
-        for index, host in zip([2, 4, 6, 8, 10], just_hosts):
-            self.assertEquals('host%02d' % index, host)
-
-        # Try some bogus input ...
-        raw = ['unknown command', ]
-        cooked = json.dumps(raw)
-        try:
-            hf.filter_hosts(self.zone_manager, cooked)
-            self.fail("Should give KeyError")
-        except KeyError, e:
-            pass
-
-        self.assertTrue(hf.filter_hosts(self.zone_manager, json.dumps([])))
-        self.assertTrue(hf.filter_hosts(self.zone_manager, json.dumps({})))
-        self.assertTrue(hf.filter_hosts(self.zone_manager, json.dumps(
-                ['not', True, False, True, False])))
-
-        try:
-            hf.filter_hosts(self.zone_manager, json.dumps(
-                'not', True, False, True, False))
-            self.fail("Should give KeyError")
-        except KeyError, e:
-            pass
-
-        self.assertFalse(hf.filter_hosts(self.zone_manager,
-                json.dumps(['=', '$foo', 100])))
-        self.assertFalse(hf.filter_hosts(self.zone_manager,
-                json.dumps(['=', '$.....', 100])))
-        self.assertFalse(hf.filter_hosts(self.zone_manager,
-                json.dumps(
-            ['>', ['and', ['or', ['not', ['<', ['>=', ['<=', ['in', ]]]]]]]])))
-
-        self.assertFalse(hf.filter_hosts(self.zone_manager,
-                json.dumps(['=', {}, ['>', '$missing....foo']])))
diff --git a/nova/tests/test_libvirt.py b/nova/tests/test_libvirt.py
index 688518bb8..6a213b4f0 100644
--- a/nova/tests/test_libvirt.py
+++ b/nova/tests/test_libvirt.py
@@ -836,6 +836,7 @@ class LibvirtConnTestCase(test.TestCase):
             count = (0 <= str(e.message).find('Unexpected method call'))
 
         shutil.rmtree(os.path.join(FLAGS.instances_path, instance.name))
+        shutil.rmtree(os.path.join(FLAGS.instances_path, '_base'))
 
         self.assertTrue(count)
 
diff --git a/nova/tests/test_metadata.py b/nova/tests/test_metadata.py
index ad678714e..b06e5c136 100644
--- a/nova/tests/test_metadata.py
+++ b/nova/tests/test_metadata.py
@@ -23,12 +23,21 @@ import httplib
 
 import webob
 
+from nova import exception
 from nova import test
 from nova import wsgi
 from nova.api.ec2 import metadatarequesthandler
 from nova.db.sqlalchemy import api
 
 
+USER_DATA_STRING = ("This is an encoded string")
+ENCODE_USER_DATA_STRING = base64.b64encode(USER_DATA_STRING)
+
+
+def return_non_existing_server_by_address(context, address):
+    raise exception.NotFound()
+
+
 class MetadataTestCase(test.TestCase):
     """Test that metadata is returning proper values."""
 
@@ -39,7 +48,7 @@ class MetadataTestCase(test.TestCase):
                          'key_name': None,
                          'host': 'test',
                          'launch_index': 1,
-                         'instance_type': 'm1.tiny',
+                         'instance_type': {'name': 'm1.tiny'},
                          'reservation_id': 'r-xxxxxxxx',
                          'user_data': '',
                          'image_ref': 7,
@@ -79,3 +88,34 @@ class MetadataTestCase(test.TestCase):
         self.stubs.Set(api, 'security_group_get_by_instance', sg_get)
         self.assertEqual(self.request('/meta-data/security-groups'),
                          'default\nother')
+
+    def test_user_data_non_existing_fixed_address(self):
+        self.stubs.Set(api, 'instance_get_all_by_filters',
+                       return_non_existing_server_by_address)
+        request = webob.Request.blank('/user-data')
+        request.remote_addr = "127.1.1.1"
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 404)
+
+    def test_user_data_none_fixed_address(self):
+        self.stubs.Set(api, 'instance_get_all_by_filters',
+                       return_non_existing_server_by_address)
+        request = webob.Request.blank('/user-data')
+        request.remote_addr = None
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 500)
+
+    def test_user_data_invalid_url(self):
+        request = webob.Request.blank('/user-data-invalid')
+        request.remote_addr = "127.0.0.1"
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 404)
+
+    def test_user_data_with_use_forwarded_header(self):
+        self.instance['user_data'] = ENCODE_USER_DATA_STRING
+        self.flags(use_forwarded_for=True)
+        request = webob.Request.blank('/user-data')
+        request.remote_addr = "127.0.0.1"
+        response = request.get_response(self.app)
+        self.assertEqual(response.status_int, 200)
+        self.assertEqual(response.body, USER_DATA_STRING)
diff --git a/nova/tests/test_network.py b/nova/tests/test_network.py
index c673f5d06..e5c80b6f6 100644
--- a/nova/tests/test_network.py
+++ b/nova/tests/test_network.py
@@ -108,11 +108,14 @@ floating_ip_fields = {'id': 0,
 
 vifs = [{'id': 0,
          'address': 'DE:AD:BE:EF:00:00',
+         'uuid': '00000000-0000-0000-0000-0000000000000000',
          'network_id': 0,
          'network': FakeModel(**networks[0]),
          'instance_id': 0},
         {'id': 1,
          'address': 'DE:AD:BE:EF:00:01',
+         'uuid': '00000000-0000-0000-0000-0000000000000001',
+         'network_id': 0,
          'network_id': 1,
          'network': FakeModel(**networks[1]),
          'instance_id': 0}]
@@ -163,6 +166,8 @@ class FlatNetworkTestCase(test.TestCase):
                      'ips': 'DONTCARE',
                      'label': 'test%s' % i,
                      'mac': 'DE:AD:BE:EF:00:0%s' % i,
+                     'vif_uuid': ('00000000-0000-0000-0000-000000000000000%s' %
+                                  i),
                      'rxtx_cap': 'DONTCARE',
                      'should_create_vlan': False,
                      'should_create_bridge': False}
@@ -255,7 +260,7 @@ class CommonNetworkTestCase(test.TestCase):
                 raise exception.NetworkNotFoundForCidr()
 
             def network_create_safe(self, context, net):
-                fakenet = {}
+                fakenet = dict(net)
                 fakenet['id'] = 999
                 return fakenet
 
@@ -269,6 +274,9 @@ class CommonNetworkTestCase(test.TestCase):
         def deallocate_fixed_ip(self, context, address):
             self.deallocate_called = address
 
+        def _create_fixed_ips(self, context, network_id):
+            pass
+
     def fake_create_fixed_ips(self, context, network_id):
         return None
 
@@ -286,16 +294,20 @@ class CommonNetworkTestCase(test.TestCase):
 
     def test_validate_cidrs(self):
         manager = self.FakeNetworkManager()
-        nets = manager._validate_cidrs(None, '192.168.0.0/24', 1, 256)
+        nets = manager.create_networks(None, 'fake', '192.168.0.0/24',
+                                       False, 1, 256, None, None, None,
+                                       None)
         self.assertEqual(1, len(nets))
-        cidrs = [str(net) for net in nets]
+        cidrs = [str(net['cidr']) for net in nets]
         self.assertTrue('192.168.0.0/24' in cidrs)
 
     def test_validate_cidrs_split_exact_in_half(self):
         manager = self.FakeNetworkManager()
-        nets = manager._validate_cidrs(None, '192.168.0.0/24', 2, 128)
+        nets = manager.create_networks(None, 'fake', '192.168.0.0/24',
+                                       False, 2, 128, None, None, None,
+                                       None)
         self.assertEqual(2, len(nets))
-        cidrs = [str(net) for net in nets]
+        cidrs = [str(net['cidr']) for net in nets]
         self.assertTrue('192.168.0.0/25' in cidrs)
         self.assertTrue('192.168.0.128/25' in cidrs)
 
@@ -306,9 +318,11 @@ class CommonNetworkTestCase(test.TestCase):
         manager.db.network_get_all(ctxt).AndReturn([{'id': 1,
                                      'cidr': '192.168.2.0/24'}])
         self.mox.ReplayAll()
-        nets = manager._validate_cidrs(None, '192.168.0.0/16', 4, 256)
+        nets = manager.create_networks(None, 'fake', '192.168.0.0/16',
+                                       False, 4, 256, None, None, None,
+                                       None)
         self.assertEqual(4, len(nets))
-        cidrs = [str(net) for net in nets]
+        cidrs = [str(net['cidr']) for net in nets]
         exp_cidrs = ['192.168.0.0/24', '192.168.1.0/24', '192.168.3.0/24',
                      '192.168.4.0/24']
         for exp_cidr in exp_cidrs:
@@ -324,8 +338,9 @@ class CommonNetworkTestCase(test.TestCase):
         self.mox.ReplayAll()
         # ValueError: requested cidr (192.168.2.0/24) conflicts with
         #             existing smaller cidr
-        args = [None, '192.168.2.0/24', 1, 256]
-        self.assertRaises(ValueError, manager._validate_cidrs, *args)
+        args = (None, 'fake', '192.168.2.0/24', False, 1, 256, None, None,
+                None, None)
+        self.assertRaises(ValueError, manager.create_networks, *args)
 
     def test_validate_cidrs_split_smaller_cidr_in_use(self):
         manager = self.FakeNetworkManager()
@@ -334,9 +349,10 @@ class CommonNetworkTestCase(test.TestCase):
         manager.db.network_get_all(ctxt).AndReturn([{'id': 1,
                                      'cidr': '192.168.2.0/25'}])
         self.mox.ReplayAll()
-        nets = manager._validate_cidrs(None, '192.168.0.0/16', 4, 256)
+        nets = manager.create_networks(None, 'fake', '192.168.0.0/16',
+                                       False, 4, 256, None, None, None, None)
         self.assertEqual(4, len(nets))
-        cidrs = [str(net) for net in nets]
+        cidrs = [str(net['cidr']) for net in nets]
         exp_cidrs = ['192.168.0.0/24', '192.168.1.0/24', '192.168.3.0/24',
                      '192.168.4.0/24']
         for exp_cidr in exp_cidrs:
@@ -350,9 +366,10 @@ class CommonNetworkTestCase(test.TestCase):
         manager.db.network_get_all(ctxt).AndReturn([{'id': 1,
                                      'cidr': '192.168.2.9/29'}])
         self.mox.ReplayAll()
-        nets = manager._validate_cidrs(None, '192.168.2.0/24', 3, 32)
+        nets = manager.create_networks(None, 'fake', '192.168.2.0/24',
+                                       False, 3, 32, None, None, None, None)
         self.assertEqual(3, len(nets))
-        cidrs = [str(net) for net in nets]
+        cidrs = [str(net['cidr']) for net in nets]
         exp_cidrs = ['192.168.2.32/27', '192.168.2.64/27', '192.168.2.96/27']
         for exp_cidr in exp_cidrs:
             self.assertTrue(exp_cidr in cidrs)
@@ -367,17 +384,19 @@ class CommonNetworkTestCase(test.TestCase):
                   {'id': 3, 'cidr': '192.168.2.128/26'}]
         manager.db.network_get_all(ctxt).AndReturn(in_use)
         self.mox.ReplayAll()
-        args = [None, '192.168.2.0/24', 3, 64]
+        args = (None, 'fake', '192.168.2.0/24', False, 3, 64, None, None,
+                None, None)
         # ValueError: Not enough subnets avail to satisfy requested num_
         #             networks - some subnets in requested range already
         #             in use
-        self.assertRaises(ValueError, manager._validate_cidrs, *args)
+        self.assertRaises(ValueError, manager.create_networks, *args)
 
     def test_validate_cidrs_one_in_use(self):
         manager = self.FakeNetworkManager()
-        args = [None, '192.168.0.0/24', 2, 256]
+        args = (None, 'fake', '192.168.0.0/24', False, 2, 256, None, None,
+                None, None)
         # ValueError: network_size * num_networks exceeds cidr size
-        self.assertRaises(ValueError, manager._validate_cidrs, *args)
+        self.assertRaises(ValueError, manager.create_networks, *args)
 
     def test_validate_cidrs_already_used(self):
         manager = self.FakeNetworkManager()
@@ -387,20 +406,23 @@ class CommonNetworkTestCase(test.TestCase):
                                      'cidr': '192.168.0.0/24'}])
         self.mox.ReplayAll()
         # ValueError: cidr already in use
-        args = [None, '192.168.0.0/24', 1, 256]
-        self.assertRaises(ValueError, manager._validate_cidrs, *args)
+        args = (None, 'fake', '192.168.0.0/24', False, 1, 256, None, None,
+                None, None)
+        self.assertRaises(ValueError, manager.create_networks, *args)
 
     def test_validate_cidrs_too_many(self):
         manager = self.FakeNetworkManager()
-        args = [None, '192.168.0.0/24', 200, 256]
+        args = (None, 'fake', '192.168.0.0/24', False, 200, 256, None, None,
+                None, None)
         # ValueError: Not enough subnets avail to satisfy requested
         #             num_networks
-        self.assertRaises(ValueError, manager._validate_cidrs, *args)
+        self.assertRaises(ValueError, manager.create_networks, *args)
 
     def test_validate_cidrs_split_partial(self):
         manager = self.FakeNetworkManager()
-        nets = manager._validate_cidrs(None, '192.168.0.0/16', 2, 256)
-        returned_cidrs = [str(net) for net in nets]
+        nets = manager.create_networks(None, 'fake', '192.168.0.0/16',
+                                       False, 2, 256, None, None, None, None)
+        returned_cidrs = [str(net['cidr']) for net in nets]
         self.assertTrue('192.168.0.0/24' in returned_cidrs)
         self.assertTrue('192.168.1.0/24' in returned_cidrs)
 
@@ -411,10 +433,11 @@ class CommonNetworkTestCase(test.TestCase):
         fakecidr = [{'id': 1, 'cidr': '192.168.0.0/8'}]
         manager.db.network_get_all(ctxt).AndReturn(fakecidr)
         self.mox.ReplayAll()
-        args = [None, '192.168.0.0/24', 1, 256]
+        args = (None, 'fake', '192.168.0.0/24', False, 1, 256, None, None,
+                None, None)
         # ValueError: requested cidr (192.168.0.0/24) conflicts
         #             with existing supernet
-        self.assertRaises(ValueError, manager._validate_cidrs, *args)
+        self.assertRaises(ValueError, manager.create_networks, *args)
 
     def test_create_networks(self):
         cidr = '192.168.0.0/24'
@@ -424,7 +447,7 @@ class CommonNetworkTestCase(test.TestCase):
         args = [None, 'foo', cidr, None, 1, 256, 'fd00::/48', None, None,
                 None]
         result = manager.create_networks(*args)
-        self.assertEqual(manager.create_networks(*args), None)
+        self.assertTrue(manager.create_networks(*args))
 
     def test_create_networks_cidr_already_used(self):
         manager = self.FakeNetworkManager()
@@ -444,4 +467,4 @@ class CommonNetworkTestCase(test.TestCase):
                                 self.fake_create_fixed_ips)
         args = [None, 'foo', cidr, None, 10, 256, 'fd00::/48', None, None,
                 None]
-        self.assertEqual(manager.create_networks(*args), None)
+        self.assertTrue(manager.create_networks(*args))
diff --git a/nova/tests/test_service.py b/nova/tests/test_service.py
index 8f92406ff..760b150be 100644
--- a/nova/tests/test_service.py
+++ b/nova/tests/test_service.py
@@ -205,6 +205,6 @@ class TestLauncher(test.TestCase):
     def test_launch_app(self):
         self.assertEquals(0, self.service.port)
         launcher = service.Launcher()
-        launcher.launch_service(self.service)
+        launcher.launch_server(self.service)
         self.assertEquals(0, self.service.port)
         launcher.stop()
diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
index ec5098a37..28e366a8e 100644
--- a/nova/tests/test_utils.py
+++ b/nova/tests/test_utils.py
@@ -384,3 +384,13 @@ class ToPrimitiveTestCase(test.TestCase):
     def test_typeerror(self):
         x = bytearray  # Class, not instance
         self.assertEquals(utils.to_primitive(x), u"<type 'bytearray'>")
+
+    def test_nasties(self):
+        def foo():
+            pass
+        x = [datetime, foo, dir]
+        ret = utils.to_primitive(x)
+        self.assertEquals(len(ret), 3)
+        self.assertTrue(ret[0].startswith(u"<module 'datetime' from "))
+        self.assertTrue(ret[1].startswith(u'<function foo at 0x'))
+        self.assertEquals(ret[2], u'<built-in function dir>')
diff --git a/nova/utils.py b/nova/utils.py
index 7276b6bd5..b42f76457 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -260,8 +260,9 @@ def default_flagfile(filename='nova.conf', args=None):
             filename = "./nova.conf"
             if not os.path.exists(filename):
                 filename = '/etc/nova/nova.conf'
-        flagfile = '--flagfile=%s' % filename
-        args.insert(1, flagfile)
+        if os.path.exists(filename):
+            flagfile = '--flagfile=%s' % filename
+            args.insert(1, flagfile)
 
 
 def debug(arg):
@@ -546,11 +547,17 @@ def to_primitive(value, convert_instances=False, level=0):
     Therefore, convert_instances=True is lossy ... be aware.
 
     """
-    if inspect.isclass(value):
-        return unicode(value)
+    nasty = [inspect.ismodule, inspect.isclass, inspect.ismethod,
+             inspect.isfunction, inspect.isgeneratorfunction,
+             inspect.isgenerator, inspect.istraceback, inspect.isframe,
+             inspect.iscode, inspect.isbuiltin, inspect.isroutine,
+             inspect.isabstract]
+    for test in nasty:
+        if test(value):
+            return unicode(value)
 
     if level > 3:
-        return []
+        return '?'
 
     # The try block may not be necessary after the class check above,
     # but just in case ...
@@ -837,39 +844,3 @@ def bool_from_str(val):
         return True if int(val) else False
     except ValueError:
         return val.lower() == 'true'
-
-
-class Bootstrapper(object):
-    """Provides environment bootstrapping capabilities for entry points."""
-
-    @staticmethod
-    def bootstrap_binary(argv):
-        """Initialize the Nova environment using command line arguments."""
-        Bootstrapper.setup_flags(argv)
-        Bootstrapper.setup_logging()
-        Bootstrapper.log_flags()
-
-    @staticmethod
-    def setup_logging():
-        """Initialize logging and log a message indicating the Nova version."""
-        logging.setup()
-        logging.audit(_("Nova Version (%s)") %
-                        version.version_string_with_vcs())
-
-    @staticmethod
-    def setup_flags(input_flags):
-        """Initialize flags, load flag file, and print help if needed."""
-        default_flagfile(args=input_flags)
-        FLAGS(input_flags or [])
-        flags.DEFINE_flag(flags.HelpFlag())
-        flags.DEFINE_flag(flags.HelpshortFlag())
-        flags.DEFINE_flag(flags.HelpXMLFlag())
-        FLAGS.ParseNewFlags()
-
-    @staticmethod
-    def log_flags():
-        """Log the list of all active flags being used."""
-        logging.audit(_("Currently active flags:"))
-        for key in FLAGS:
-            value = FLAGS.get(key, None)
-            logging.audit(_("%(key)s : %(value)s" % locals()))
diff --git a/nova/virt/libvirt/connection.py b/nova/virt/libvirt/connection.py
index 2b17e244a..e8a657bac 100644
--- a/nova/virt/libvirt/connection.py
+++ b/nova/virt/libvirt/connection.py
@@ -1538,8 +1538,9 @@ class LibvirtConnection(driver.ComputeDriver):
         # If any instances never launch at destination host,
         # basic-filtering must be set here.
         self.firewall_driver.setup_basic_filtering(instance_ref, network_info)
-        # setting up n)ova-instance-instance-xx mainly.
-        self.firewall_driver.prepare_instance_filter(instance_ref, network_info)
+        # setting up nova-instance-instance-xx mainly.
+        self.firewall_driver.prepare_instance_filter(instance_ref,
+                network_info)
 
         # wait for completion
         timeout_count = range(FLAGS.live_migration_retry_count)
diff --git a/nova/virt/libvirt/vif.py b/nova/virt/libvirt/vif.py
index 4cb9abda4..0b7438011 100644
--- a/nova/virt/libvirt/vif.py
+++ b/nova/virt/libvirt/vif.py
@@ -80,12 +80,14 @@ class LibvirtBridgeDriver(VIFDriver):
                 LOG.debug(_('Ensuring vlan %(vlan)s and bridge %(bridge)s'),
                           {'vlan': network['vlan'],
                            'bridge': network['bridge']})
-                linux_net.ensure_vlan_bridge(network['vlan'],
+                linux_net.LinuxBridgeInterfaceDriver.ensure_vlan_bridge(
+                                             network['vlan'],
                                              network['bridge'],
                                              network['bridge_interface'])
             else:
                 LOG.debug(_("Ensuring bridge %s"), network['bridge'])
-                linux_net.ensure_bridge(network['bridge'],
+                linux_net.LinuxBridgeInterfaceDriver.ensure_bridge(
+                                        network['bridge'],
                                         network['bridge_interface'])
 
         return self._get_configurations(network, mapping)
@@ -98,10 +100,12 @@ class LibvirtBridgeDriver(VIFDriver):
 class LibvirtOpenVswitchDriver(VIFDriver):
     """VIF driver for Open vSwitch."""
 
+    def get_dev_name(_self, iface_id):
+        return "tap-" + iface_id[0:15]
+
     def plug(self, instance, network, mapping):
-        vif_id = str(instance['id']) + "-" + str(network['id'])
-        dev = "tap-%s" % vif_id
-        iface_id = "nova-" + vif_id
+        iface_id = mapping['vif_uuid']
+        dev = self.get_dev_name(iface_id)
         if not linux_net._device_exists(dev):
             utils.execute('ip', 'tuntap', 'add', dev, 'mode', 'tap',
                           run_as_root=True)
@@ -125,11 +129,10 @@ class LibvirtOpenVswitchDriver(VIFDriver):
     def unplug(self, instance, network, mapping):
         """Unplug the VIF from the network by deleting the port from
         the bridge."""
-        vif_id = str(instance['id']) + "-" + str(network['id'])
-        dev = "tap-%s" % vif_id
+        dev = self.get_dev_name(mapping['vif_uuid'])
         try:
             utils.execute('ovs-vsctl', 'del-port',
-                          network['bridge'], dev, run_as_root=True)
+                          FLAGS.libvirt_ovs_bridge, dev, run_as_root=True)
             utils.execute('ip', 'link', 'delete', dev, run_as_root=True)
         except exception.ProcessExecutionError:
             LOG.warning(_("Failed while unplugging vif of instance '%s'"),
diff --git a/nova/virt/xenapi/vif.py b/nova/virt/xenapi/vif.py
index 527602243..2f25efeb2 100644
--- a/nova/virt/xenapi/vif.py
+++ b/nova/virt/xenapi/vif.py
@@ -128,12 +128,12 @@ class XenAPIOpenVswitchDriver(VIFDriver):
         vif_rec['VM'] = vm_ref
         vif_rec['MAC'] = network_mapping['mac']
         vif_rec['MTU'] = '1500'
-        vif_id = "nova-" + str(instance['id']) + "-" + str(network['id'])
         vif_rec['qos_algorithm_type'] = ""
         vif_rec['qos_algorithm_params'] = {}
         # OVS on the hypervisor monitors this key and uses it to
         # set the iface-id attribute
-        vif_rec['other_config'] = {"nicira-iface-id": vif_id}
+        vif_rec['other_config'] = \
+                {"nicira-iface-id": network_mapping['vif_uuid']}
         return vif_rec
 
     def unplug(self, instance, network, mapping):
diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index eb0a846b5..9a6215f88 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -709,9 +709,6 @@ class VMOps(object):
         if resp['returncode'] != '0':
             LOG.error(_('Failed to update password: %(resp)r') % locals())
             return None
-        db.instance_update(nova_context.get_admin_context(),
-                                  instance['id'],
-                                  dict(admin_pass=new_pass))
         return resp['message']
 
     def inject_file(self, instance, path, contents):
diff --git a/nova/wsgi.py b/nova/wsgi.py
index c8ddb97d7..09b45be5a 100644
--- a/nova/wsgi.py
+++ b/nova/wsgi.py
@@ -39,9 +39,6 @@ from nova import log as logging
 from nova import utils
 
 
-eventlet.patcher.monkey_patch(socket=True, time=True)
-
-
 FLAGS = flags.FLAGS
 LOG = logging.getLogger('nova.wsgi')
 
@@ -274,18 +271,6 @@ class Middleware(Application):
         return self.process_response(response)
 
 
-class InjectContext(Middleware):
-    """Add a 'nova.context' to WSGI environ."""
-    def __init__(self, context, *args, **kwargs):
-        self.context = context
-        super(InjectContext, self).__init__(*args, **kwargs)
-
-    @webob.dec.wsgify(RequestClass=Request)
-    def __call__(self, req):
-        req.environ['nova.context'] = self.context
-        return self.application
-
-
 class Debug(Middleware):
     """Helper class for debugging a WSGI application.
 
diff --git a/plugins/xenserver/xenapi/etc/xapi.d/plugins/xenhost b/plugins/xenserver/xenapi/etc/xapi.d/plugins/xenhost
index cd9694ce1..36c61f78d 100755
--- a/plugins/xenserver/xenapi/etc/xapi.d/plugins/xenhost
+++ b/plugins/xenserver/xenapi/etc/xapi.d/plugins/xenhost
@@ -258,6 +258,7 @@ def cleanup(dct):
 #    out["host_suspend-image-sr-uuid"] = dct.get("suspend-image-sr-uuid", "")
 #    out["host_crash-dump-sr-uuid"] = dct.get("crash-dump-sr-uuid", "")
 #    out["host_local-cache-sr"] = dct.get("local-cache-sr", "")
+    out["enabled"] = dct.get("enabled", "true") == "true"
     out["host_memory"] = omm = {}
     omm["total"] = safe_int(dct.get("memory-total", ""))
     omm["overhead"] = safe_int(dct.get("memory-overhead", ""))
diff --git a/smoketests/test_netadmin.py b/smoketests/test_netadmin.py
index 8c8fa35b8..ef73e6f4c 100644
--- a/smoketests/test_netadmin.py
+++ b/smoketests/test_netadmin.py
@@ -107,14 +107,18 @@ class AddressTests(base.UserSmokeTestCase):
 
 class SecurityGroupTests(base.UserSmokeTestCase):
 
-    def __public_instance_is_accessible(self):
-        id_url = "latest/meta-data/instance-id"
+    def __get_metadata_item(self, category):
+        id_url = "latest/meta-data/%s" % category
         options = "-f -s --max-time 1"
         command = "curl %s %s/%s" % (options, self.data['public_ip'], id_url)
         status, output = commands.getstatusoutput(command)
-        instance_id = output.strip()
+        value = output.strip()
         if status > 0:
             return False
+        return value
+
+    def __public_instance_is_accessible(self):
+        instance_id = self.__get_metadata_item('instance-id')
         if not instance_id:
             return False
         if instance_id != self.data['instance'].id:
@@ -166,7 +170,14 @@ class SecurityGroupTests(base.UserSmokeTestCase):
         finally:
             result = self.conn.disassociate_address(self.data['public_ip'])
 
-    def test_005_can_revoke_security_group_ingress(self):
+    def test_005_validate_metadata(self):
+
+        instance = self.data['instance']
+        self.assertTrue(instance.instance_type,
+                            self.__get_metadata_item("instance-type"))
+        #FIXME(dprince): validate more metadata here
+
+    def test_006_can_revoke_security_group_ingress(self):
         self.assertTrue(self.conn.revoke_security_group(TEST_GROUP,
                                                         ip_protocol='tcp',
                                                         from_port=80,