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

[Ryu Ishimoto]

Merged trunk

=== modified file '.bzrignore'
--- .bzrignore	2011-02-21 20:35:30 +0000
+++ .bzrignore	2011-04-12 11:01:25 +0000
@@ -5,12 +5,11 @@
 keys
 networks
 nova.sqlite
-CA/cacert.pem
-CA/crl.pem
-CA/index.txt*
-CA/openssl.cnf
-CA/serial*
-CA/newcerts/*.pem
-CA/private/cakey.pem
+CA
 nova/vcsversion.py
 *.DS_Store
+.project
+.pydevproject
+clean.sqlite
+run_tests.log
+tests.sqlite
 
=== modified file 'Authors'
--- Authors	2011-03-25 13:38:57 +0000
+++ Authors	2011-04-12 11:01:25 +0000
@@ -12,6 +12,7 @@
 Chmouel Boudjnah <[e-mail]>
 Chris Behrens <[e-mail]>
 Christian Berendt <[e-mail]>
+Chuck Short <[e-mail]>
 Cory Wright <[e-mail]>
 Dan Prince <[e-mail]>
 David Pravec <[e-mail]>
@@ -30,7 +31,9 @@
 Jesse Andrews <[e-mail]>
 Joe Heck <[e-mail]>
 Joel Moore <[e-mail]>
+Johannes Erdfelt <[e-mail]>
 John Dewey <[e-mail]>
+John Tran <[e-mail]>
 Jonathan Bryce <[e-mail]>
 Jordan Rinke <[e-mail]>
 Josh Durgin <[e-mail]>
 
=== modified file 'MANIFEST.in'
--- MANIFEST.in	2011-03-14 20:10:11 +0000
+++ MANIFEST.in	2011-04-12 11:01:25 +0000
@@ -1,7 +1,7 @@
 include HACKING LICENSE run_tests.py run_tests.sh
 include README builddeb.sh exercise_rsapi.py
 include ChangeLog MANIFEST.in pylintrc Authors
-graft CA
+graft nova/CA
 graft doc
 graft smoketests
 graft tools
 
=== modified file 'bin/nova-ajax-console-proxy'
--- bin/nova-ajax-console-proxy	2011-03-18 13:56:05 +0000
+++ bin/nova-ajax-console-proxy	2011-04-12 11:01:25 +0000
@@ -108,17 +108,17 @@
             return "Server Error"
 
     def register_listeners(self):
-        class Callback:
-            def __call__(self, data, message):
-                if data['method'] == 'authorize_ajax_console':
-                    AjaxConsoleProxy.tokens[data['args']['token']] =  \
-                        {'args': data['args'], 'last_activity': time.time()}
+        class TopicProxy():
+            @staticmethod
+            def authorize_ajax_console(context, **kwargs):
+                AjaxConsoleProxy.tokens[kwargs['token']] =  \
+                    {'args': kwargs, 'last_activity': time.time()}
 
         conn = rpc.Connection.instance(new=True)
-        consumer = rpc.TopicConsumer(
-                        connection=conn,
-                        topic=FLAGS.ajax_console_proxy_topic)
-        consumer.register_callback(Callback())
+        consumer = rpc.TopicAdapterConsumer(
+                       connection=conn,
+                       proxy=TopicProxy,
+                       topic=FLAGS.ajax_console_proxy_topic)
 
         def delete_expired_tokens():
             now = time.time()
@@ -130,8 +130,7 @@
             for k in to_delete:
                 del AjaxConsoleProxy.tokens[k]
 
-        utils.LoopingCall(consumer.fetch, auto_ack=True,
-                          enable_callbacks=True).start(0.1)
+        utils.LoopingCall(consumer.fetch, enable_callbacks=True).start(0.1)
         utils.LoopingCall(delete_expired_tokens).start(1)
 
 if __name__ == '__main__':
 
=== modified file 'bin/nova-dhcpbridge'
--- bin/nova-dhcpbridge	2011-03-14 17:59:41 +0000
+++ bin/nova-dhcpbridge	2011-04-12 11:01:25 +0000
@@ -48,6 +48,7 @@
 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')
 
@@ -103,7 +104,8 @@
     utils.default_flagfile(flagfile)
     argv = FLAGS(sys.argv)
     logging.setup()
-    interface = os.environ.get('DNSMASQ_INTERFACE', 'br0')
+    # 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
     action = argv[1]
 
=== modified file 'bin/nova-manage'
--- bin/nova-manage	2011-04-07 14:25:01 +0000
+++ bin/nova-manage	2011-04-12 11:01:25 +0000
@@ -528,6 +528,49 @@
 class VmCommands(object):
     """Class for mangaging VM instances."""
 
+    def list(self, host=None):
+        """Show a list of all instances
+
+        :param host: show all instance on specified host.
+        :param instance: show specificed instance.
+        """
+        print "%-10s %-15s %-10s %-10s %-19s %-12s %-12s %-12s" \
+              "  %-10s %-10s %-10s %-5s" % (
+            _('instance'),
+            _('node'),
+            _('type'),
+            _('state'),
+            _('launched'),
+            _('image'),
+            _('kernel'),
+            _('ramdisk'),
+            _('project'),
+            _('user'),
+            _('zone'),
+            _('index'))
+
+        if host == None:
+            instances = db.instance_get_all(context.get_admin_context())
+        else:
+            instances = db.instance_get_all_by_host(
+                           context.get_admin_context(), host)
+
+        for instance in instances:
+            print "%-10s %-15s %-10s %-10s %-19s %-12s %-12s %-12s" \
+                  "  %-10s %-10s %-10s %-5d" % (
+                instance['hostname'],
+                instance['host'],
+                instance['instance_type'],
+                instance['state_description'],
+                instance['launched_at'],
+                instance['image_id'],
+                instance['kernel_id'],
+                instance['ramdisk_id'],
+                instance['project_id'],
+                instance['user_id'],
+                instance['availability_zone'],
+                instance['launch_index'])
+
     def live_migration(self, ec2_id, dest):
         """Migrates a running instance to a new machine.
 
@@ -659,15 +702,6 @@
                  {"method": "update_available_resource"})
 
 
-class LogCommands(object):
-    def request(self, request_id, logfile='/var/log/nova.log'):
-        """Show all fields in the log for the given request.  Assumes you
-        haven't changed the log format too much.
-        ARGS: request_id [logfile]"""
-        lines = utils.execute("cat %s | grep '\[%s '" % (logfile, request_id))
-        print re.sub('#012', "\n", "\n".join(lines))
-
-
 class DbCommands(object):
     """Class for managing the database."""
 
@@ -683,49 +717,6 @@
         print migration.db_version()
 
 
-class InstanceCommands(object):
-    """Class for managing instances."""
-
-    def list(self, host=None, instance=None):
-        """Show a list of all instances"""
-        print "%-10s %-15s %-10s %-10s %-19s %-12s %-12s %-12s" \
-              "  %-10s %-10s %-10s %-5s" % (
-            _('instance'),
-            _('node'),
-            _('type'),
-            _('state'),
-            _('launched'),
-            _('image'),
-            _('kernel'),
-            _('ramdisk'),
-            _('project'),
-            _('user'),
-            _('zone'),
-            _('index'))
-
-        if host == None:
-            instances = db.instance_get_all(context.get_admin_context())
-        else:
-            instances = db.instance_get_all_by_host(
-                           context.get_admin_context(), host)
-
-        for instance in instances:
-            print "%-10s %-15s %-10s %-10s %-19s %-12s %-12s %-12s" \
-                  "  %-10s %-10s %-10s %-5d" % (
-                instance['hostname'],
-                instance['host'],
-                instance['instance_type'],
-                instance['state_description'],
-                instance['launched_at'],
-                instance['image_id'],
-                instance['kernel_id'],
-                instance['ramdisk_id'],
-                instance['project_id'],
-                instance['user_id'],
-                instance['availability_zone'],
-                instance['launch_index'])
-
-
 class VolumeCommands(object):
     """Methods for dealing with a cloud in an odd state"""
 
@@ -836,7 +827,7 @@
             elif name == "--all":
                 inst_types = instance_types.get_all_types(True)
             else:
-                inst_types = instance_types.get_instance_type(name)
+                inst_types = instance_types.get_instance_type_by_name(name)
         except exception.DBError, e:
             _db_error(e)
         if isinstance(inst_types.values()[0], dict):
@@ -852,20 +843,17 @@
     def __init__(self, *args, **kwargs):
         self.image_service = utils.import_object(FLAGS.image_service)
 
-    def _register(self, image_type, disk_format, container_format,
+    def _register(self, container_format, disk_format,
                   path, owner, name=None, is_public='T',
                   architecture='x86_64', kernel_id=None, ramdisk_id=None):
-        meta = {'is_public': True,
+        meta = {'is_public': (is_public == 'T'),
                 'name': name,
+                'container_format': container_format,
                 'disk_format': disk_format,
-                'container_format': container_format,
                 'properties': {'image_state': 'available',
-                               'owner': owner,
-                               'type': image_type,
+                               'project_id': owner,
                                'architecture': architecture,
-                               'image_location': 'local',
-                               'is_public': (is_public == 'T')}}
-        print image_type, meta
+                               'image_location': 'local'}}
         if kernel_id:
             meta['properties']['kernel_id'] = int(kernel_id)
         if ramdisk_id:
@@ -890,16 +878,18 @@
         ramdisk_id = self.ramdisk_register(ramdisk, owner, None,
                                     is_public, architecture)
         self.image_register(image, owner, name, is_public,
-                       architecture, kernel_id, ramdisk_id)
+                            architecture, 'ami', 'ami',
+                            kernel_id, ramdisk_id)
 
     def image_register(self, path, owner, name=None, is_public='T',
-                       architecture='x86_64', kernel_id=None, ramdisk_id=None,
-                       disk_format='ami', container_format='ami'):
+                       architecture='x86_64', container_format='bare',
+                       disk_format='raw', kernel_id=None, ramdisk_id=None):
         """Uploads an image into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
+                   [container_format='bare'] [disk_format='raw']
                    [kernel_id=None] [ramdisk_id=None]
-                   [disk_format='ami'] [container_format='ami']"""
-        return self._register('machine', disk_format, container_format, path,
+        """
+        return self._register(container_format, disk_format, path,
                               owner, name, is_public, architecture,
                               kernel_id, ramdisk_id)
 
@@ -908,7 +898,7 @@
         """Uploads a kernel into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        return self._register('kernel', 'aki', 'aki', path, owner, name,
+        return self._register('aki', 'aki', path, owner, name,
                               is_public, architecture)
 
     def ramdisk_register(self, path, owner, name=None, is_public='T',
@@ -916,7 +906,7 @@
         """Uploads a ramdisk into the image_service
         arguments: path owner [name] [is_public='T'] [architecture='x86_64']
         """
-        return self._register('ramdisk', 'ari', 'ari', path, owner, name,
+        return self._register('ari', 'ari', path, owner, name,
                               is_public, architecture)
 
     def _lookup(self, old_image_id):
@@ -933,16 +923,17 @@
                    'ramdisk': 'ari'}
         container_format = mapping[old['type']]
         disk_format = container_format
+        if container_format == 'ami' and not old.get('kernelId'):
+            container_format = 'bare'
+            disk_format = 'raw'
         new = {'disk_format': disk_format,
                'container_format': container_format,
-               'is_public': True,
+               'is_public': old['isPublic'],
                'name': old['imageId'],
                'properties': {'image_state': old['imageState'],
-                              'owner': old['imageOwnerId'],
+                              'project_id': old['imageOwnerId'],
                               'architecture': old['architecture'],
-                              'type': old['type'],
-                              'image_location': old['imageLocation'],
-                              'is_public': old['isPublic']}}
+                              'image_location': old['imageLocation']}}
         if old.get('kernelId'):
             new['properties']['kernel_id'] = self._lookup(old['kernelId'])
         if old.get('ramdiskId'):
@@ -1006,13 +997,11 @@
     ('floating', FloatingIpCommands),
     ('vm', VmCommands),
     ('service', ServiceCommands),
-    ('log', LogCommands),
     ('db', DbCommands),
     ('volume', VolumeCommands),
     ('instance_type', InstanceTypeCommands),
     ('image', ImageCommands),
-    ('flavor', InstanceTypeCommands),
-    ('instance', InstanceCommands)]
+    ('flavor', InstanceTypeCommands)]
 
 
 def lazy_match(name, key_value_tuples):
@@ -1055,8 +1044,8 @@
     script_name = argv.pop(0)
     if len(argv) < 1:
         print script_name + " category action [<args>]"
-        print "Available categories:"
-        for k, _ in CATEGORIES:
+        print _("Available categories:")
+        for k, _v in CATEGORIES:
             print "\t%s" % k
         sys.exit(2)
     category = argv.pop(0)
@@ -1067,7 +1056,7 @@
     actions = methods_of(command_object)
     if len(argv) < 1:
         print script_name + " category action [<args>]"
-        print "Available actions for %s category:" % category
+        print _("Available actions for %s category:") % category
         for k, _v in actions:
             print "\t%s" % k
         sys.exit(2)
@@ -1079,9 +1068,12 @@
         fn(*argv)
         sys.exit(0)
     except TypeError:
-        print "Possible wrong number of arguments supplied"
+        print _("Possible wrong number of arguments supplied")
         print "%s %s: %s" % (category, action, fn.__doc__)
         raise
+    except Exception:
+        print _("Command failed, please check log for more info")
+        raise
 
 if __name__ == '__main__':
     main()
 
=== added file 'bin/nova-vncproxy'
--- bin/nova-vncproxy	1970-01-01 00:00:00 +0000
+++ bin/nova-vncproxy	2011-04-12 11:01:25 +0000
@@ -0,0 +1,101 @@
+#!/usr/bin/env python
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2010 Openstack, LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License");
+#    you may not use this file except in compliance with the License.
+#    You may obtain a copy of the License at
+#
+#        http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS,
+#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#    See the License for the specific language governing permissions and
+#    limitations under the License.
+
+"""VNC Console Proxy Server."""
+
+import eventlet
+import gettext
+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)
+
+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 import version
+from nova.vnc import auth
+from nova.vnc import proxy
+
+
+LOG = logging.getLogger('nova.vnc-proxy')
+
+
+FLAGS = flags.FLAGS
+flags.DEFINE_string('vncproxy_wwwroot', '/var/lib/nova/noVNC/',
+                     'Full path to noVNC directory')
+flags.DEFINE_boolean('vnc_debug', False,
+                     'Enable debugging features, like token bypassing')
+flags.DEFINE_integer('vncproxy_port', 6080,
+                     'Port that the VNC proxy should bind to')
+flags.DEFINE_string('vncproxy_host', '0.0.0.0',
+                     'Address that the VNC proxy should bind to')
+flags.DEFINE_integer('vnc_token_ttl', 300,
+                     'How many seconds before deleting tokens')
+flags.DEFINE_string('vncproxy_manager', 'nova.vnc.auth.VNCProxyAuthManager',
+                    'Manager for vncproxy auth')
+
+flags.DEFINE_flag(flags.HelpFlag())
+flags.DEFINE_flag(flags.HelpshortFlag())
+flags.DEFINE_flag(flags.HelpXMLFlag())
+
+
+if __name__ == "__main__":
+    utils.default_flagfile()
+    FLAGS(sys.argv)
+    logging.setup()
+
+    LOG.audit(_("Starting nova-vnc-proxy node (version %s)"),
+              version.version_string_with_vcs())
+
+    if not (os.path.exists(FLAGS.vncproxy_wwwroot) and
+            os.path.exists(FLAGS.vncproxy_wwwroot + '/vnc_auto.html')):
+        LOG.info(_("Missing vncproxy_wwwroot (version %s)"),
+                    FLAGS.vncproxy_wwwroot)
+        LOG.info(_("You need a slightly modified version of noVNC "
+                   "to work with the nova-vnc-proxy"))
+        LOG.info(_("Check out the most recent nova noVNC code: %s"),
+                   "git://github.com/sleepsonthefloor/noVNC.git")
+        LOG.info(_("And drop it in %s"), FLAGS.vncproxy_wwwroot)
+        exit(1)
+
+    app = proxy.WebsocketVNCProxy(FLAGS.vncproxy_wwwroot)
+
+    LOG.audit(_("Allowing access to the following files: %s"),
+              app.get_whitelist())
+
+    with_logging = auth.LoggingMiddleware(app)
+
+    if FLAGS.vnc_debug:
+        with_auth = proxy.DebugMiddleware(with_logging)
+    else:
+        with_auth = auth.VNCNovaAuthMiddleware(with_logging)
+
+    service.serve()
+
+    server = wsgi.Server()
+    server.start(with_auth, FLAGS.vncproxy_port, host=FLAGS.vncproxy_host)
+    server.wait()
 
=== added file 'doc/source/devref/zone.rst'
--- doc/source/devref/zone.rst	1970-01-01 00:00:00 +0000
+++ doc/source/devref/zone.rst	2011-04-12 11:01:25 +0000
@@ -0,0 +1,127 @@
+..
+      Copyright 2010-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.
+
+Zones
+=====
+
+A Nova deployment is called a Zone. At the very least a Zone requires an API node, a Scheduler node, a database and RabbitMQ. Pushed further a Zone may contain many API nodes, many Scheduler, Volume, Network and Compute nodes as well as a cluster of databases and RabbitMQ servers. A Zone allows you to partition your deployments into logical groups for load balancing and instance distribution.
+
+The idea behind Zones is, if a particular deployment is not capable of servicing a particular request, the request may be forwarded to (child) Zones for possible processing. Zones may be nested in a tree fashion. 
+
+Zones only know about their immediate children, they do not know about their parent Zones and may in fact have more than one parent. Likewise, a Zone's children may themselves have child Zones. 
+
+Zones share nothing. They communicate via the public OpenStack API only. No database, queue, user or project definition is shared between Zones. 
+
+
+Capabilities
+------------
+Routing between Zones is based on the Capabilities of that Zone. Capabilities are nothing more than key/value pairs. Values are multi-value, with each value separated with a semicolon (`;`). When expressed as a string they take the form:
+
+::
+
+  key=value;value;value, key=value;value;value
+
+Zones have Capabilities which are general to the Zone and are set via `--zone-capabilities` flag. Zones also have dynamic per-service Capabilities. Services derived from `nova.manager.SchedulerDependentManager` (such as Compute, Volume and Network) can set these capabilities by calling the `update_service_capabilities()` method on their `Manager` base class. These capabilities will be periodically sent to the Scheduler service automatically. The rate at which these updates are sent is controlled by the `--periodic_interval` flag.
+
+Flow within a Zone
+------------------
+The brunt of the work within a Zone is done in the Scheduler Service. The Scheduler is responsible for:
+- collecting capability messages from the Compute, Volume and Network nodes,
+- polling the child Zones for their status and
+- providing data to the Distributed Scheduler for performing load balancing calculations
+
+Inter-service communication within a Zone is done with RabbitMQ. Each class of Service (Compute, Volume and Network) has both a named message exchange (particular to that host) and a general message exchange (particular to that class of service). Messages sent to these exchanges are picked off in round-robin fashion. Zones introduce a new fan-out exchange per service. Messages sent to the fan-out exchange are picked up by all services of a particular class. This fan-out exchange is used by the Scheduler services to receive capability messages from the Compute, Volume and Network nodes.
+
+These capability messages are received by the Scheduler services and stored in the `ZoneManager` object. The SchedulerManager object has a reference to the `ZoneManager` it can use for load balancing.
+
+The `ZoneManager` also polls the child Zones periodically to gather their capabilities to aid in decision making. This is done via the OpenStack API `/v1.0/zones/info` REST call. This also captures the name of each child Zone. The Zone name is set via the `--zone-name` flag (and defaults to "nova"). 
+
+Zone administrative functions
+-----------------------------
+Zone administrative operations are usually done using python-novaclient_
+
+.. _python-novaclient: https://github.com/rackspace/python-novaclient
+
+In order to use the Zone operations, be sure to enable administrator operations in OpenStack API by setting the `--allow_admin_api=true` flag.
+
+Finally you need to enable Zone Forwarding. This will be used by the Distributed Scheduler initiative currently underway. Set `--enable_zone_routing=true` to enable this feature.
+
+Find out about this Zone
+------------------------
+In any Zone you can find the Zone's name and capabilities with the ``nova zone-info`` command.
+
+::
+
+  alice@novadev:~$ nova zone-info
+  +-----------------+---------------+
+  |     Property    |     Value     |
+  +-----------------+---------------+
+  | compute_cpu     | 0.7,0.7       |
+  | compute_disk    | 123000,123000 |
+  | compute_network | 800,800       |
+  | hypervisor      | xenserver     |
+  | name            | nova          |
+  | network_cpu     | 0.7,0.7       |
+  | network_disk    | 123000,123000 |
+  | network_network | 800,800       |
+  | os              | linux         |
+  +-----------------+---------------+
+
+This equates to a GET operation on `.../zones/info`. If you have no child Zones defined you'll usually only get back the default `name`, `hypervisor` and `os` capabilities. Otherwise you'll get back a tuple of min, max values for each capabilities of all the hosts of all the services running in the child zone. These take the `<service>_<capability> = <min>,<max>` format.
+
+Adding a child Zone
+-------------------
+Any Zone can be a parent Zone. Children are associated to a Zone. The Zone where this command originates from is known as the Parent Zone. Routing is only ever conducted from a Zone to its children, never the other direction. From a parent zone you can add a child zone with the following command:
+
+::
+
+  nova zone-add <child zone api url> <username> <nova api key>
+
+You can get the `child zone api url`, `nova api key` and `username` from the `novarc` file in the child zone. For example:
+
+::
+
+  export NOVA_API_KEY="3bd1af06-6435-4e23-a827-413b2eb86934"
+  export NOVA_USERNAME="alice"
+  export NOVA_URL="http://192.168.2.120:8774/v1.0/"
+
+
+This equates to a POST operation to `.../zones/` to add a new zone. No connection attempt to the child zone is done when this command. It only puts an entry in the db at this point. After about 30 seconds the `ZoneManager` in the Scheduler services will attempt to talk to the child zone and get its information. 
+
+Getting a list of child Zones
+-----------------------------
+
+::
+
+  nova zone-list
+
+  alice@novadev:~$ nova zone-list
+  +----+-------+-----------+--------------------------------------------+---------------------------------+
+  | ID |  Name | Is Active |                Capabilities                |             API URL             |
+  +----+-------+-----------+--------------------------------------------+---------------------------------+
+  | 2  | zone1 | True      | hypervisor=xenserver;kvm, os=linux;windows | http://192.168.2.108:8774/v1.0/ |
+  | 3  | zone2 | True      | hypervisor=xenserver;kvm, os=linux;windows | http://192.168.2.115:8774/v1.0/ |
+  +----+-------+-----------+--------------------------------------------+---------------------------------+
+
+This equates to a GET operation to `.../zones`.
+
+Removing a child Zone
+---------------------
+::
+
+  nova zone-delete <N>
+
+This equates to a DELETE call to `.../zones/N`. The Zone with ID=N will be removed. This will only remove the zone entry from the current (parent) Zone, no child Zones are affected. Removing a Child Zone doesn't affect any other part of the hierarchy.
 
=== modified file 'doc/source/man/novamanage.rst'
--- doc/source/man/novamanage.rst	2011-03-08 20:28:11 +0000
+++ doc/source/man/novamanage.rst	2011-04-12 11:01:25 +0000
@@ -240,6 +240,16 @@
 
     Converts all images in directory from the old (Bexar) format to the new format.
 
+Nova VM
+~~~~~~~~~~~
+
+``nova-manage vm list [host]``
+    Show a list of all instances. Accepts optional hostname (to show only instances on specific host).
+
+``nova-manage live-migration <ec2_id> <destination host name>``
+    Live migrate instance from current host to destination host. Requires instance id (which comes from euca-describe-instance) and destination host name (which can be found from nova-manage service list).
+
+
 FILES
 ========
 
 
=== added file 'doc/source/runnova/vncconsole.rst'
--- doc/source/runnova/vncconsole.rst	1970-01-01 00:00:00 +0000
+++ doc/source/runnova/vncconsole.rst	2011-04-12 11:01:25 +0000
@@ -0,0 +1,76 @@
+..
+      Copyright 2010-2011 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.
+
+Getting Started with the VNC Proxy
+==================================
+
+The VNC Proxy is an OpenStack component that allows users of Nova to access
+their instances through a websocket enabled browser (like Google Chrome).
+
+A VNC Connection works like so:
+
+* User connects over an api and gets a url like http://ip:port/?token=xyz
+* User pastes url in browser
+* Browser connects to VNC Proxy though a websocket enabled client like noVNC
+* VNC Proxy authorizes users token, maps the token to a host and port of an
+  instance's VNC server
+* VNC Proxy initiates connection to VNC server, and continues proxying until
+  the session ends
+
+
+Configuring the VNC Proxy
+-------------------------
+nova-vncproxy requires a websocket enabled html client to work properly.  At
+this time, the only tested client is a slightly modified fork of noVNC, which
+you can at find http://github.com/openstack/noVNC.git
+
+.. todo:: add instruction for installing from package
+
+noVNC must be in the location specified by --vncproxy_wwwroot, which defaults
+to /var/lib/nova/noVNC.  nova-vncproxy will fail to launch until this code
+is properly installed.
+
+By default, nova-vncproxy binds 0.0.0.0:6080.  This can be configured with:
+
+* --vncproxy_port=[port]
+* --vncproxy_host=[host]
+
+
+Enabling VNC Consoles in Nova
+-----------------------------
+At the moment, VNC support is supported only when using libvirt.  To enable VNC
+Console, configure the following flags:
+
+* --vnc_console_proxy_url=http://[proxy_host]:[proxy_port] - proxy_port
+  defaults to 6080.  This url must point to nova-vncproxy
+* --vnc_enabled=[True|False] - defaults to True. If this flag is not set your
+  instances will launch without vnc support.
+
+
+Getting an instance's VNC Console
+---------------------------------
+You can access an instance's VNC Console url in the following methods:
+
+* Using the direct api:
+  eg: 'stack --user=admin --project=admin compute get_vnc_console instance_id=1'
+* Support for Dashboard, and the Openstack API will be forthcoming
+
+
+Accessing VNC Consoles without a web browser
+--------------------------------------------
+At the moment, VNC Consoles are only supported through the web browser, but
+more general VNC support is in the works.
 
=== added directory 'etc/nova'
=== renamed file 'etc/api-paste.ini' => 'etc/nova/api-paste.ini'
=== renamed directory 'CA' => 'nova/CA'
=== modified file 'nova/CA/geninter.sh'
--- CA/geninter.sh	2010-11-06 00:02:36 +0000
+++ nova/CA/geninter.sh	2011-04-12 11:01:25 +0000
@@ -23,7 +23,7 @@
 cd projects/$NAME
 cp ../../openssl.cnf.tmpl openssl.cnf
 sed -i -e s/%USERNAME%/$NAME/g openssl.cnf
-mkdir certs crl newcerts private
+mkdir -p certs crl newcerts private
 openssl req -new -x509 -extensions v3_ca -keyout private/cakey.pem -out cacert.pem -days 365 -config ./openssl.cnf -batch -nodes
 echo "10" > serial
 touch index.txt
 
=== modified file 'nova/CA/genrootca.sh'
--- CA/genrootca.sh	2010-11-06 00:02:36 +0000
+++ nova/CA/genrootca.sh	2011-04-12 11:01:25 +0000
@@ -20,8 +20,9 @@
 then
     echo "Not installing, it's already done."
 else
-    cp openssl.cnf.tmpl openssl.cnf
+    cp "$(dirname $0)/openssl.cnf.tmpl" openssl.cnf
     sed -i -e s/%USERNAME%/ROOT/g openssl.cnf
+    mkdir -p certs crl newcerts private
     openssl req -new -x509 -extensions v3_ca -keyout private/cakey.pem -out cacert.pem -days 365 -config ./openssl.cnf -batch -nodes
     touch index.txt
     echo "10" > serial
 
=== modified file 'nova/CA/openssl.cnf.tmpl'
--- CA/openssl.cnf.tmpl	2011-03-16 18:22:29 +0000
+++ nova/CA/openssl.cnf.tmpl	2011-04-12 11:01:25 +0000
@@ -41,9 +41,13 @@
 certopt			= default_ca
 policy			= policy_match
 
+# NOTE(dprince): stateOrProvinceName must be 'supplied' or 'optional' to
+# work around a stateOrProvince printable string UTF8 mismatch on
+# RHEL 6 and Fedora 14 (using openssl-1.0.0-4.el6.x86_64 or
+# openssl-1.0.0d-1.fc14.x86_64)
 [ policy_match ]
 countryName		= match
-stateOrProvinceName	= match
+stateOrProvinceName	= supplied
 organizationName	= optional
 organizationalUnitName	= optional
 commonName		= supplied
 
=== removed file 'nova/adminclient.py'
--- nova/adminclient.py	2011-02-24 19:36:15 +0000
+++ nova/adminclient.py	1970-01-01 00:00:00 +0000
@@ -1,476 +0,0 @@
-# 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.
-"""
-Nova User API client library.
-"""
-
-import base64
-import boto
-import boto.exception
-import httplib
-import re
-import string
-
-from boto.ec2.regioninfo import RegionInfo
-
-
-DEFAULT_CLC_URL = 'http://127.0.0.1:8773'
-DEFAULT_REGION = 'nova'
-
-
-class UserInfo(object):
-    """
-    Information about a Nova user, as parsed through SAX.
-
-    **Fields Include**
-
-    * username
-    * accesskey
-    * secretkey
-    * file (optional) containing zip of X509 cert & rc file
-
-    """
-
-    def __init__(self, connection=None, username=None, endpoint=None):
-        self.connection = connection
-        self.username = username
-        self.endpoint = endpoint
-
-    def __repr__(self):
-        return 'UserInfo:%s' % self.username
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        if name == 'username':
-            self.username = str(value)
-        elif name == 'file':
-            self.file = base64.b64decode(str(value))
-        elif name == 'accesskey':
-            self.accesskey = str(value)
-        elif name == 'secretkey':
-            self.secretkey = str(value)
-
-
-class UserRole(object):
-    """
-    Information about a Nova user's role, as parsed through SAX.
-
-    **Fields include**
-
-    * role
-
-    """
-
-    def __init__(self, connection=None):
-        self.connection = connection
-        self.role = None
-
-    def __repr__(self):
-        return 'UserRole:%s' % self.role
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        if name == 'role':
-            self.role = value
-        else:
-            setattr(self, name, str(value))
-
-
-class ProjectInfo(object):
-    """
-    Information about a Nova project, as parsed through SAX.
-
-    **Fields include**
-
-    * projectname
-    * description
-    * projectManagerId
-    * memberIds
-
-    """
-
-    def __init__(self, connection=None):
-        self.connection = connection
-        self.projectname = None
-        self.description = None
-        self.projectManagerId = None
-        self.memberIds = []
-
-    def __repr__(self):
-        return 'ProjectInfo:%s' % self.projectname
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        if name == 'projectname':
-            self.projectname = value
-        elif name == 'description':
-            self.description = value
-        elif name == 'projectManagerId':
-            self.projectManagerId = value
-        elif name == 'memberId':
-            self.memberIds.append(value)
-        else:
-            setattr(self, name, str(value))
-
-
-class ProjectMember(object):
-    """
-    Information about a Nova project member, as parsed through SAX.
-
-    **Fields include**
-
-    * memberId
-
-    """
-
-    def __init__(self, connection=None):
-        self.connection = connection
-        self.memberId = None
-
-    def __repr__(self):
-        return 'ProjectMember:%s' % self.memberId
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        if name == 'member':
-            self.memberId = value
-        else:
-            setattr(self, name, str(value))
-
-
-class HostInfo(object):
-    """
-    Information about a Nova Host, as parsed through SAX.
-
-    **Fields Include**
-
-    * Hostname
-    * Compute service status
-    * Volume service status
-    * Instance count
-    * Volume count
-    """
-
-    def __init__(self, connection=None):
-        self.connection = connection
-        self.hostname = None
-        self.compute = None
-        self.volume = None
-        self.instance_count = 0
-        self.volume_count = 0
-
-    def __repr__(self):
-        return 'Host:%s' % self.hostname
-
-    # this is needed by the sax parser, so ignore the ugly name
-    def startElement(self, name, attrs, connection):
-        return None
-
-    # this is needed by the sax parser, so ignore the ugly name
-    def endElement(self, name, value, connection):
-        fixed_name = string.lower(re.sub(r'([A-Z])', r'_\1', name))
-        setattr(self, fixed_name, value)
-
-
-class Vpn(object):
-    """
-    Information about a Vpn, as parsed through SAX
-
-    **Fields Include**
-
-    * instance_id
-    * project_id
-    * public_ip
-    * public_port
-    * created_at
-    * internal_ip
-    * state
-    """
-
-    def __init__(self, connection=None):
-        self.connection = connection
-        self.instance_id = None
-        self.project_id = None
-
-    def __repr__(self):
-        return 'Vpn:%s:%s' % (self.project_id, self.instance_id)
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        fixed_name = string.lower(re.sub(r'([A-Z])', r'_\1', name))
-        setattr(self, fixed_name, value)
-
-
-class InstanceType(object):
-    """
-    Information about a Nova instance type, as parsed through SAX.
-
-    **Fields include**
-
-    * name
-    * vcpus
-    * disk_gb
-    * memory_mb
-    * flavor_id
-
-    """
-
-    def __init__(self, connection=None):
-        self.connection = connection
-        self.name = None
-        self.vcpus = None
-        self.disk_gb = None
-        self.memory_mb = None
-        self.flavor_id = None
-
-    def __repr__(self):
-        return 'InstanceType:%s' % self.name
-
-    def startElement(self, name, attrs, connection):
-        return None
-
-    def endElement(self, name, value, connection):
-        if name == "memoryMb":
-            self.memory_mb = str(value)
-        elif name == "flavorId":
-            self.flavor_id = str(value)
-        elif name == "diskGb":
-            self.disk_gb = str(value)
-        else:
-            setattr(self, name, str(value))
-
-
-class NovaAdminClient(object):
-
-    def __init__(
-            self,
-            clc_url=DEFAULT_CLC_URL,
-            region=DEFAULT_REGION,
-            access_key=None,
-            secret_key=None,
-            **kwargs):
-        parts = self.split_clc_url(clc_url)
-
-        self.clc_url = clc_url
-        self.region = region
-        self.access = access_key
-        self.secret = secret_key
-        self.apiconn = boto.connect_ec2(aws_access_key_id=access_key,
-                                        aws_secret_access_key=secret_key,
-                                        is_secure=parts['is_secure'],
-                                        region=RegionInfo(None,
-                                                          region,
-                                                          parts['ip']),
-                                        port=parts['port'],
-                                        path='/services/Admin',
-                                        **kwargs)
-        self.apiconn.APIVersion = 'nova'
-
-    def connection_for(self, username, project, clc_url=None, region=None,
-                       **kwargs):
-        """Returns a boto ec2 connection for the given username."""
-        if not clc_url:
-            clc_url = self.clc_url
-        if not region:
-            region = self.region
-        parts = self.split_clc_url(clc_url)
-        user = self.get_user(username)
-        access_key = '%s:%s' % (user.accesskey, project)
-        return boto.connect_ec2(aws_access_key_id=access_key,
-                                aws_secret_access_key=user.secretkey,
-                                is_secure=parts['is_secure'],
-                                region=RegionInfo(None,
-                                                  self.region,
-                                                  parts['ip']),
-                                port=parts['port'],
-                                path='/services/Cloud',
-                                **kwargs)
-
-    def split_clc_url(self, clc_url):
-        """Splits a cloud controller endpoint url."""
-        parts = httplib.urlsplit(clc_url)
-        is_secure = parts.scheme == 'https'
-        ip, port = parts.netloc.split(':')
-        return {'ip': ip, 'port': int(port), 'is_secure': is_secure}
-
-    def get_users(self):
-        """Grabs the list of all users."""
-        return self.apiconn.get_list('DescribeUsers', {}, [('item', UserInfo)])
-
-    def get_user(self, name):
-        """Grab a single user by name."""
-        try:
-            return self.apiconn.get_object('DescribeUser',
-                                           {'Name': name},
-                                           UserInfo)
-        except boto.exception.BotoServerError, e:
-            if e.status == 400 and e.error_code == 'NotFound':
-                return None
-            raise
-
-    def has_user(self, username):
-        """Determine if user exists."""
-        return self.get_user(username) != None
-
-    def create_user(self, username):
-        """Creates a new user, returning the userinfo object with
-        access/secret."""
-        return self.apiconn.get_object('RegisterUser', {'Name': username},
-                                       UserInfo)
-
-    def delete_user(self, username):
-        """Deletes a user."""
-        return self.apiconn.get_object('DeregisterUser', {'Name': username},
-                                       UserInfo)
-
-    def get_roles(self, project_roles=True):
-        """Returns a list of available roles."""
-        return self.apiconn.get_list('DescribeRoles',
-                                     {'ProjectRoles': project_roles},
-                                     [('item', UserRole)])
-
-    def get_user_roles(self, user, project=None):
-        """Returns a list of roles for the given user.
-
-        Omitting project will return any global roles that the user has.
-        Specifying project will return only project specific roles.
-
-        """
-        params = {'User': user}
-        if project:
-            params['Project'] = project
-        return self.apiconn.get_list('DescribeUserRoles',
-                                     params,
-                                     [('item', UserRole)])
-
-    def add_user_role(self, user, role, project=None):
-        """Add a role to a user either globally or for a specific project."""
-        return self.modify_user_role(user, role, project=project,
-                                     operation='add')
-
-    def remove_user_role(self, user, role, project=None):
-        """Remove a role from a user either globally or for a specific
-        project."""
-        return self.modify_user_role(user, role, project=project,
-                                     operation='remove')
-
-    def modify_user_role(self, user, role, project=None, operation='add',
-                         **kwargs):
-        """Add or remove a role for a user and project."""
-        params = {'User': user,
-                  'Role': role,
-                  'Project': project,
-                  'Operation': operation}
-        return self.apiconn.get_status('ModifyUserRole', params)
-
-    def get_projects(self, user=None):
-        """Returns a list of all projects."""
-        if user:
-            params = {'User': user}
-        else:
-            params = {}
-        return self.apiconn.get_list('DescribeProjects',
-                                     params,
-                                     [('item', ProjectInfo)])
-
-    def get_project(self, name):
-        """Returns a single project with the specified name."""
-        project = self.apiconn.get_object('DescribeProject',
-                                          {'Name': name},
-                                          ProjectInfo)
-
-        if project.projectname != None:
-            return project
-
-    def create_project(self, projectname, manager_user, description=None,
-                       member_users=None):
-        """Creates a new project."""
-        params = {'Name': projectname,
-                  'ManagerUser': manager_user,
-                  'Description': description,
-                  'MemberUsers': member_users}
-        return self.apiconn.get_object('RegisterProject', params, ProjectInfo)
-
-    def modify_project(self, projectname, manager_user=None, description=None):
-        """Modifies an existing project."""
-        params = {'Name': projectname,
-                  'ManagerUser': manager_user,
-                  'Description': description}
-        return self.apiconn.get_status('ModifyProject', params)
-
-    def delete_project(self, projectname):
-        """Permanently deletes the specified project."""
-        return self.apiconn.get_object('DeregisterProject',
-                                       {'Name': projectname},
-                                       ProjectInfo)
-
-    def get_project_members(self, name):
-        """Returns a list of members of a project."""
-        return self.apiconn.get_list('DescribeProjectMembers',
-                                     {'Name': name},
-                                     [('item', ProjectMember)])
-
-    def add_project_member(self, user, project):
-        """Adds a user to a project."""
-        return self.modify_project_member(user, project, operation='add')
-
-    def remove_project_member(self, user, project):
-        """Removes a user from a project."""
-        return self.modify_project_member(user, project, operation='remove')
-
-    def modify_project_member(self, user, project, operation='add'):
-        """Adds or removes a user from a project."""
-        params = {'User': user,
-                  'Project': project,
-                  'Operation': operation}
-        return self.apiconn.get_status('ModifyProjectMember', params)
-
-    def get_zip(self, user, project):
-        """Returns the content of a zip file containing novarc and access
-        credentials."""
-        params = {'Name': user, 'Project': project}
-        zip = self.apiconn.get_object('GenerateX509ForUser', params, UserInfo)
-        return zip.file
-
-    def start_vpn(self, project):
-        """
-        Starts the vpn for a user
-        """
-        return self.apiconn.get_object('StartVpn', {'Project': project}, Vpn)
-
-    def get_vpns(self):
-        """Return a list of vpn with project name"""
-        return self.apiconn.get_list('DescribeVpns', {}, [('item', Vpn)])
-
-    def get_hosts(self):
-        return self.apiconn.get_list('DescribeHosts', {}, [('item', HostInfo)])
-
-    def get_instance_types(self):
-        """Grabs the list of all users."""
-        return self.apiconn.get_list('DescribeInstanceTypes', {},
-                                     [('item', InstanceType)])
 
=== modified file 'nova/api/direct.py'
--- nova/api/direct.py	2011-03-24 20:20:15 +0000
+++ nova/api/direct.py	2011-04-12 11:01:25 +0000
@@ -206,10 +206,14 @@
         # NOTE(vish): make sure we have no unicode keys for py2.6.
         params = dict([(str(k), v) for (k, v) in params.iteritems()])
         result = method(context, **params)
+
         if result is None or type(result) is str or type(result) is unicode:
             return result
+
         try:
-            return self._serialize(result, req.best_match_content_type())
+            content_type = req.best_match_content_type()
+            default_xmlns = self.get_default_xmlns(req)
+            return self._serialize(result, content_type, default_xmlns)
         except:
             raise exception.Error("returned non-serializable type: %s"
                                   % result)
 
=== modified file 'nova/api/ec2/cloud.py'
--- nova/api/ec2/cloud.py	2011-04-07 08:40:22 +0000
+++ nova/api/ec2/cloud.py	2011-04-12 11:01:25 +0000
@@ -103,10 +103,18 @@
         # Gen root CA, if we don't have one
         root_ca_path = os.path.join(FLAGS.ca_path, FLAGS.ca_file)
         if not os.path.exists(root_ca_path):
+            genrootca_sh_path = os.path.join(os.path.dirname(__file__),
+                                             os.path.pardir,
+                                             os.path.pardir,
+                                             'CA',
+                                             'genrootca.sh')
+
             start = os.getcwd()
+            if not os.path.exists(FLAGS.ca_path):
+                os.makedirs(FLAGS.ca_path)
             os.chdir(FLAGS.ca_path)
             # TODO(vish): Do this with M2Crypto instead
-            utils.runthis(_("Generating root CA: %s"), "sh", "genrootca.sh")
+            utils.runthis(_("Generating root CA: %s"), "sh", genrootca_sh_path)
             os.chdir(start)
 
     def _get_mpi_data(self, context, project_id):
@@ -134,6 +142,11 @@
         instance_ref = self.compute_api.get_all(ctxt, fixed_ip=address)
         if instance_ref is None:
             return None
+
+        # This ensures that all attributes of the instance
+        # are populated.
+        instance_ref = db.instance_get(ctxt, instance_ref['id'])
+
         mpi = self._get_mpi_data(ctxt, instance_ref['project_id'])
         if instance_ref['key_name']:
             keys = {'0': {'_name': instance_ref['key_name'],
@@ -156,7 +169,7 @@
                 floating_ip = net['IPs'][0]['floating_ips'][0]
 
         ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
-        image_ec2_id = self._image_ec2_id(instance_ref['image_id'], 'machine')
+        image_ec2_id = self._image_ec2_id(instance_ref['image_id'], 'ami')
         data = {
             'user-data': base64.b64decode(instance_ref['user_data']),
             'meta-data': {
@@ -186,7 +199,7 @@
         for image_type in ['kernel', 'ramdisk']:
             if '%s_id' % image_type in instance_ref:
                 ec2_id = self._image_ec2_id(instance_ref['%s_id' % image_type],
-                                            image_type)
+                                            self._image_type(image_type))
                 data['meta-data']['%s-id' % image_type] = ec2_id
 
         if False:  # TODO(vish): store ancestor ids
@@ -546,6 +559,13 @@
         return self.compute_api.get_ajax_console(context,
                                                  instance_id=instance_id)
 
+    def get_vnc_console(self, context, instance_id, **kwargs):
+        """Returns vnc browser url.  Used by OS dashboard."""
+        ec2_id = instance_id
+        instance_id = ec2utils.ec2_id_to_id(ec2_id)
+        return self.compute_api.get_vnc_console(context,
+                                                instance_id=instance_id)
+
     def describe_volumes(self, context, volume_id=None, **kwargs):
         if volume_id:
             volumes = []
@@ -734,7 +754,10 @@
                     instance['project_id'],
                     instance['host'])
             i['productCodesSet'] = self._convert_to_set([], 'product_codes')
-            i['instanceType'] = instance['instance_type']
+            if instance['instance_type']:
+                i['instanceType'] = instance['instance_type'].get('name')
+            else:
+                i['instanceType'] = None
             i['launchTime'] = instance['created_at']
             i['amiLaunchIndex'] = instance['launch_index']
             i['displayName'] = instance['display_name']
@@ -763,6 +786,7 @@
 
     def format_addresses(self, context):
         addresses = []
+
         net_factory = net_service.get_service_factory(context,
                                                       context.project_id)
         net_api = net_factory.get_api_service()
@@ -770,6 +794,9 @@
         ip_info_list = net_api.get_addresses(context, project_id)
 
         for ip_info in ip_info_list:
+            if ip_info['project_id'] is None:
+                continue
+
             ec2_id = None
             if ip_info['vnic_id']:
                 instance = db.instance_get_by_virtual_nic(context,
@@ -788,6 +815,7 @@
 
     def allocate_address(self, context, **kwargs):
         LOG.audit(_("Allocate address"), context=context)
+
         net_factory = net_service.get_service_factory(context,
                                                       context.project_id)
         net_api_service = net_factory.get_api_service()
@@ -802,7 +830,7 @@
                          context.project_id)
             raise ex
 
-        return {'addressSet': [{'publicIp': public_ip}]}
+        return {'publicIp': public_ip}
 
     def release_address(self, context, public_ip, **kwargs):
         LOG.audit(_("Release address %s"), public_ip, context=context)
@@ -841,7 +869,7 @@
             ramdisk = self._get_image(context, kwargs['ramdisk_id'])
             kwargs['ramdisk_id'] = ramdisk['id']
         instances = self.compute_api.create(context,
-            instance_type=instance_types.get_by_type(
+            instance_type=instance_types.get_instance_type_by_name(
                 kwargs.get('instance_type', None)),
             image_id=self._get_image(context, kwargs['image_id'])['id'],
             min_count=int(kwargs.get('min_count', max_count)),
@@ -898,13 +926,27 @@
             self.compute_api.update(context, instance_id=instance_id, **kwargs)
         return True
 
-    _type_prefix_map = {'machine': 'ami',
-                        'kernel': 'aki',
-                        'ramdisk': 'ari'}
-
-    def _image_ec2_id(self, image_id, image_type='machine'):
-        prefix = self._type_prefix_map[image_type]
-        template = prefix + '-%08x'
+    @staticmethod
+    def _image_type(image_type):
+        """Converts to a three letter image type.
+
+        aki, kernel => aki
+        ari, ramdisk => ari
+        anything else => ami
+
+        """
+        if image_type == 'kernel':
+            return 'aki'
+        if image_type == 'ramdisk':
+            return 'ari'
+        if image_type not in ['aki', 'ari']:
+            return 'ami'
+        return image_type
+
+    @staticmethod
+    def _image_ec2_id(image_id, image_type='ami'):
+        """Returns image ec2_id using id and three letter type."""
+        template = image_type + '-%08x'
         return ec2utils.id_to_ec2_id(int(image_id), template=template)
 
     def _get_image(self, context, ec2_id):
@@ -917,24 +959,34 @@
     def _format_image(self, image):
         """Convert from format defined by BaseImageService to S3 format."""
         i = {}
-        image_type = image['properties'].get('type')
+        image_type = self._image_type(image.get('container_format'))
         ec2_id = self._image_ec2_id(image.get('id'), image_type)
         name = image.get('name')
-        if name:
-            i['imageId'] = "%s (%s)" % (ec2_id, name)
-        else:
-            i['imageId'] = ec2_id
+        i['imageId'] = ec2_id
         kernel_id = image['properties'].get('kernel_id')
         if kernel_id:
-            i['kernelId'] = self._image_ec2_id(kernel_id, 'kernel')
+            i['kernelId'] = self._image_ec2_id(kernel_id, 'aki')
         ramdisk_id = image['properties'].get('ramdisk_id')
         if ramdisk_id:
-            i['ramdiskId'] = self._image_ec2_id(ramdisk_id, 'ramdisk')
+            i['ramdiskId'] = self._image_ec2_id(ramdisk_id, 'ari')
         i['imageOwnerId'] = image['properties'].get('owner_id')
-        i['imageLocation'] = image['properties'].get('image_location')
-        i['imageState'] = image['properties'].get('image_state')
-        i['type'] = image_type
-        i['isPublic'] = str(image['properties'].get('is_public', '')) == 'True'
+        if name:
+            i['imageLocation'] = "%s (%s)" % (image['properties'].
+                                              get('image_location'), name)
+        else:
+            i['imageLocation'] = image['properties'].get('image_location')
+        # NOTE(vish): fallback status if image_state isn't set
+        state = image.get('status')
+        if state == 'active':
+            state = 'available'
+        i['imageState'] = image['properties'].get('image_state', state)
+        i['displayName'] = name
+        i['description'] = image.get('description')
+        display_mapping = {'aki': 'kernel',
+                           'ari': 'ramdisk',
+                           'ami': 'machine'}
+        i['imageType'] = display_mapping.get(image_type)
+        i['isPublic'] = image.get('is_public') == True
         i['architecture'] = image['properties'].get('architecture')
         return i
 
@@ -966,8 +1018,9 @@
             image_location = kwargs['name']
         metadata = {'properties': {'image_location': image_location}}
         image = self.image_service.create(context, metadata)
+        image_type = self._image_type(image.get('container_format'))
         image_id = self._image_ec2_id(image['id'],
-                                      image['properties']['type'])
+                                      image_type)
         msg = _("Registered image %(image_location)s with"
                 " id %(image_id)s") % locals()
         LOG.audit(msg, context=context)
@@ -982,7 +1035,7 @@
         except exception.NotFound:
             raise exception.NotFound(_('Image %s not found') % image_id)
         result = {'imageId': image_id, 'launchPermission': []}
-        if image['properties']['is_public']:
+        if image['is_public']:
             result['launchPermission'].append({'group': 'all'})
         return result
 
@@ -1007,7 +1060,7 @@
         internal_id = image['id']
         del(image['id'])
 
-        image['properties']['is_public'] = (operation_type == 'add')
+        image['is_public'] = (operation_type == 'add')
         return self.image_service.update(context, internal_id, image)
 
     def update_image(self, context, image_id, **kwargs):
 
=== modified file 'nova/api/openstack/__init__.py'
--- nova/api/openstack/__init__.py	2011-04-07 01:08:35 +0000
+++ nova/api/openstack/__init__.py	2011-04-12 11:01:25 +0000
@@ -36,6 +36,7 @@
 from nova.api.openstack import flavors
 from nova.api.openstack import images
 from nova.api.openstack import image_metadata
+from nova.api.openstack import ips
 from nova.api.openstack import limits
 from nova.api.openstack import servers
 from nova.api.openstack import server_metadata
@@ -108,23 +109,11 @@
                             controller=accounts.Controller(),
                             collection={'detail': 'GET'})
 
-        mapper.resource("backup_schedule", "backup_schedule",
-                        controller=backup_schedules.Controller(),
-                        parent_resource=dict(member_name='server',
-                        collection_name='servers'))
-
         mapper.resource("console", "consoles",
                         controller=consoles.Controller(),
                         parent_resource=dict(member_name='server',
                         collection_name='servers'))
 
-        mapper.resource("image", "images", controller=images.Controller(),
-                        collection={'detail': 'GET'})
-
-        mapper.resource("shared_ip_group", "shared_ip_groups",
-                        collection={'detail': 'GET'},
-                        controller=shared_ip_groups.Controller())
-
         _limits = limits.LimitsController()
         mapper.resource("limit", "limits", controller=_limits)
 
@@ -144,10 +133,28 @@
                         collection={'detail': 'GET'},
                         member=self.server_members)
 
+        mapper.resource("image", "images",
+                        controller=images.ControllerV10(),
+                        collection={'detail': 'GET'})
+
         mapper.resource("flavor", "flavors",
                         controller=flavors.ControllerV10(),
                         collection={'detail': 'GET'})
 
+        mapper.resource("shared_ip_group", "shared_ip_groups",
+                        collection={'detail': 'GET'},
+                        controller=shared_ip_groups.Controller())
+
+        mapper.resource("backup_schedule", "backup_schedule",
+                        controller=backup_schedules.Controller(),
+                        parent_resource=dict(member_name='server',
+                        collection_name='servers'))
+
+        mapper.resource("ip", "ips", controller=ips.Controller(),
+                        collection=dict(public='GET', private='GET'),
+                        parent_resource=dict(member_name='server',
+                                             collection_name='servers'))
+
 
 class APIRouterV11(APIRouter):
     """Define routes specific to OpenStack API V1.1."""
@@ -159,6 +166,10 @@
                         collection={'detail': 'GET'},
                         member=self.server_members)
 
+        mapper.resource("image", "images",
+                        controller=images.ControllerV11(),
+                        collection={'detail': 'GET'})
+
         mapper.resource("image_meta", "meta",
                         controller=image_metadata.Controller(),
                         parent_resource=dict(member_name='image',
 
=== modified file 'nova/api/openstack/accounts.py'
--- nova/api/openstack/accounts.py	2011-03-18 14:34:08 +0000
+++ nova/api/openstack/accounts.py	2011-04-12 11:01:25 +0000
@@ -13,15 +13,14 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import common
 import webob.exc
 
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import wsgi
 
 from nova.auth import manager
+from nova.api.openstack import common
 from nova.api.openstack import faults
 
 FLAGS = flags.FLAGS
@@ -35,7 +34,7 @@
                 manager=account.project_manager_id)
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
 
     _serialization_metadata = {
         'application/xml': {
 
=== modified file 'nova/api/openstack/backup_schedules.py'
--- nova/api/openstack/backup_schedules.py	2011-03-09 18:10:45 +0000
+++ nova/api/openstack/backup_schedules.py	2011-04-12 11:01:25 +0000
@@ -19,7 +19,7 @@
 
 from webob import exc
 
-from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import faults
 import nova.image.service
 
@@ -29,7 +29,7 @@
     return dict(backupSchedule=inst)
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
     """ The backup schedule API controller for the Openstack API """
 
     _serialization_metadata = {
@@ -42,7 +42,11 @@
 
     def index(self, req, server_id):
         """ Returns the list of backup schedules for a given instance """
-        return _translate_keys({})
+        return faults.Fault(exc.HTTPNotImplemented())
+
+    def show(self, req, server_id, id):
+        """ Returns a single backup schedule for a given instance """
+        return faults.Fault(exc.HTTPNotImplemented())
 
     def create(self, req, server_id):
         """ No actual update method required, since the existing API allows
 
=== modified file 'nova/api/openstack/common.py'
--- nova/api/openstack/common.py	2011-03-24 23:34:52 +0000
+++ nova/api/openstack/common.py	2011-04-12 11:01:25 +0000
@@ -21,10 +21,20 @@
 
 from nova import exception
 from nova import flags
+from nova import log as logging
+from nova import wsgi
+
+
+LOG = logging.getLogger('common')
+
 
 FLAGS = flags.FLAGS
 
 
+XML_NS_V10 = 'http://docs.rackspacecloud.com/servers/api/v1.0'
+XML_NS_V11 = 'http://docs.openstack.org/compute/api/v1.1'
+
+
 def limited(items, request, max_limit=FLAGS.osapi_max_limit):
     """
     Return a slice of items according to requested offset and limit.
@@ -121,4 +131,11 @@
     try:
         return int(urlparse(href).path.split('/')[-1])
     except:
+        LOG.debug(_("Error extracting id from href: %s") % href)
         raise webob.exc.HTTPBadRequest(_('could not parse id from href'))
+
+
+class OpenstackController(wsgi.Controller):
+    def get_default_xmlns(self, req):
+        # Use V10 by default
+        return XML_NS_V10
 
=== modified file 'nova/api/openstack/consoles.py'
--- nova/api/openstack/consoles.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/consoles.py	2011-04-12 11:01:25 +0000
@@ -19,7 +19,7 @@
 
 from nova import console
 from nova import exception
-from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import faults
 
 
@@ -43,7 +43,7 @@
     return dict(console=info)
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
     """The Consoles Controller for the Openstack API"""
 
     _serialization_metadata = {
 
=== added directory 'nova/api/openstack/contrib'
=== added file 'nova/api/openstack/contrib/__init__.py'
--- nova/api/openstack/contrib/__init__.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/contrib/__init__.py	2011-04-12 11:01:25 +0000
@@ -0,0 +1,22 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Justin Santa Barbara
+# 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 datetime
+
+"""Contrib contains extensions that are shipped with nova.
+
+It can't be called 'extensions' because that causes namespacing problems.
+
+"""
 
=== added file 'nova/api/openstack/contrib/volumes.py'
--- nova/api/openstack/contrib/volumes.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/contrib/volumes.py	2011-04-12 11:01:25 +0000
@@ -0,0 +1,336 @@
+# Copyright 2011 Justin Santa Barbara
+# 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 volumes extension."""
+
+from webob import exc
+
+from nova import compute
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import volume
+from nova import wsgi
+from nova.api.openstack import common
+from nova.api.openstack import extensions
+from nova.api.openstack import faults
+
+
+LOG = logging.getLogger("nova.api.volumes")
+
+
+FLAGS = flags.FLAGS
+
+
+def _translate_volume_detail_view(context, vol):
+    """Maps keys for volumes details view."""
+
+    d = _translate_volume_summary_view(context, vol)
+
+    # No additional data / lookups at the moment
+
+    return d
+
+
+def _translate_volume_summary_view(context, vol):
+    """Maps keys for volumes summary view."""
+    d = {}
+
+    d['id'] = vol['id']
+    d['status'] = vol['status']
+    d['size'] = vol['size']
+    d['availabilityZone'] = vol['availability_zone']
+    d['createdAt'] = vol['created_at']
+
+    if vol['attach_status'] == 'attached':
+        d['attachments'] = [_translate_attachment_detail_view(context, vol)]
+    else:
+        d['attachments'] = [{}]
+
+    d['displayName'] = vol['display_name']
+    d['displayDescription'] = vol['display_description']
+    return d
+
+
+class VolumeController(wsgi.Controller):
+    """The Volumes API controller for the OpenStack API."""
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "volume": [
+                    "id",
+                    "status",
+                    "size",
+                    "availabilityZone",
+                    "createdAt",
+                    "displayName",
+                    "displayDescription",
+                    ]}}}
+
+    def __init__(self):
+        self.volume_api = volume.API()
+        super(VolumeController, self).__init__()
+
+    def show(self, req, id):
+        """Return data about the given volume."""
+        context = req.environ['nova.context']
+
+        try:
+            vol = self.volume_api.get(context, id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        return {'volume': _translate_volume_detail_view(context, vol)}
+
+    def delete(self, req, id):
+        """Delete a volume."""
+        context = req.environ['nova.context']
+
+        LOG.audit(_("Delete volume with id: %s"), id, context=context)
+
+        try:
+            self.volume_api.delete(context, volume_id=id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        return exc.HTTPAccepted()
+
+    def index(self, req):
+        """Returns a summary list of volumes."""
+        return self._items(req, entity_maker=_translate_volume_summary_view)
+
+    def detail(self, req):
+        """Returns a detailed list of volumes."""
+        return self._items(req, entity_maker=_translate_volume_detail_view)
+
+    def _items(self, req, entity_maker):
+        """Returns a list of volumes, transformed through entity_maker."""
+        context = req.environ['nova.context']
+
+        volumes = self.volume_api.get_all(context)
+        limited_list = common.limited(volumes, req)
+        res = [entity_maker(context, vol) for vol in limited_list]
+        return {'volumes': res}
+
+    def create(self, req):
+        """Creates a new volume."""
+        context = req.environ['nova.context']
+
+        env = self._deserialize(req.body, req.get_content_type())
+        if not env:
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        vol = env['volume']
+        size = vol['size']
+        LOG.audit(_("Create volume of %s GB"), size, context=context)
+        new_volume = self.volume_api.create(context, size,
+                                            vol.get('display_name'),
+                                            vol.get('display_description'))
+
+        # Work around problem that instance is lazy-loaded...
+        new_volume['instance'] = None
+
+        retval = _translate_volume_detail_view(context, new_volume)
+
+        return {'volume': retval}
+
+
+def _translate_attachment_detail_view(_context, vol):
+    """Maps keys for attachment details view."""
+
+    d = _translate_attachment_summary_view(_context, vol)
+
+    # No additional data / lookups at the moment
+
+    return d
+
+
+def _translate_attachment_summary_view(_context, vol):
+    """Maps keys for attachment summary view."""
+    d = {}
+
+    volume_id = vol['id']
+
+    # NOTE(justinsb): We use the volume id as the id of the attachment object
+    d['id'] = volume_id
+
+    d['volumeId'] = volume_id
+    if vol.get('instance_id'):
+        d['serverId'] = vol['instance_id']
+    if vol.get('mountpoint'):
+        d['device'] = vol['mountpoint']
+
+    return d
+
+
+class VolumeAttachmentController(wsgi.Controller):
+    """The volume attachment API controller for the Openstack API.
+
+    A child resource of the server.  Note that we use the volume id
+    as the ID of the attachment (though this is not guaranteed externally)
+
+    """
+
+    _serialization_metadata = {
+        'application/xml': {
+            'attributes': {
+                'volumeAttachment': ['id',
+                                     'serverId',
+                                     'volumeId',
+                                     'device']}}}
+
+    def __init__(self):
+        self.compute_api = compute.API()
+        self.volume_api = volume.API()
+        super(VolumeAttachmentController, self).__init__()
+
+    def index(self, req, server_id):
+        """Returns the list of volume attachments for a given instance."""
+        return self._items(req, server_id,
+                           entity_maker=_translate_attachment_summary_view)
+
+    def show(self, req, server_id, id):
+        """Return data about the given volume attachment."""
+        context = req.environ['nova.context']
+
+        volume_id = id
+        try:
+            vol = self.volume_api.get(context, volume_id)
+        except exception.NotFound:
+            LOG.debug("volume_id not found")
+            return faults.Fault(exc.HTTPNotFound())
+
+        if str(vol['instance_id']) != server_id:
+            LOG.debug("instance_id != server_id")
+            return faults.Fault(exc.HTTPNotFound())
+
+        return {'volumeAttachment': _translate_attachment_detail_view(context,
+                                                                      vol)}
+
+    def create(self, req, server_id):
+        """Attach a volume to an instance."""
+        context = req.environ['nova.context']
+
+        env = self._deserialize(req.body, req.get_content_type())
+        if not env:
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+
+        instance_id = server_id
+        volume_id = env['volumeAttachment']['volumeId']
+        device = env['volumeAttachment']['device']
+
+        msg = _("Attach volume %(volume_id)s to instance %(server_id)s"
+                " at %(device)s") % locals()
+        LOG.audit(msg, context=context)
+
+        try:
+            self.compute_api.attach_volume(context,
+                                           instance_id=instance_id,
+                                           volume_id=volume_id,
+                                           device=device)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        # The attach is async
+        attachment = {}
+        attachment['id'] = volume_id
+        attachment['volumeId'] = volume_id
+
+        # NOTE(justinsb): And now, we have a problem...
+        # The attach is async, so there's a window in which we don't see
+        # the attachment (until the attachment completes).  We could also
+        # get problems with concurrent requests.  I think we need an
+        # attachment state, and to write to the DB here, but that's a bigger
+        # change.
+        # For now, we'll probably have to rely on libraries being smart
+
+        # TODO(justinsb): How do I return "accepted" here?
+        return {'volumeAttachment': attachment}
+
+    def update(self, _req, _server_id, _id):
+        """Update a volume attachment.  We don't currently support this."""
+        return faults.Fault(exc.HTTPBadRequest())
+
+    def delete(self, req, server_id, id):
+        """Detach a volume from an instance."""
+        context = req.environ['nova.context']
+
+        volume_id = id
+        LOG.audit(_("Detach volume %s"), volume_id, context=context)
+
+        try:
+            vol = self.volume_api.get(context, volume_id)
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+
+        if str(vol['instance_id']) != server_id:
+            LOG.debug("instance_id != server_id")
+            return faults.Fault(exc.HTTPNotFound())
+
+        self.compute_api.detach_volume(context,
+                                       volume_id=volume_id)
+
+        return exc.HTTPAccepted()
+
+    def _items(self, req, server_id, entity_maker):
+        """Returns a list of attachments, 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())
+
+        volumes = instance['volumes']
+        limited_list = common.limited(volumes, req)
+        res = [entity_maker(context, vol) for vol in limited_list]
+        return {'volumeAttachments': res}
+
+
+class Volumes(extensions.ExtensionDescriptor):
+    def get_name(self):
+        return "Volumes"
+
+    def get_alias(self):
+        return "VOLUMES"
+
+    def get_description(self):
+        return "Volumes support"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/volumes/api/v1.1"
+
+    def get_updated(self):
+        return "2011-03-25T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = []
+
+        # NOTE(justinsb): No way to provide singular name ('volume')
+        # Does this matter?
+        res = extensions.ResourceExtension('volumes',
+                                        VolumeController(),
+                                        collection_actions={'detail': 'GET'}
+                                          )
+        resources.append(res)
+
+        res = extensions.ResourceExtension('volume_attachments',
+                                           VolumeAttachmentController(),
+                                           parent=dict(
+                                                member_name='server',
+                                                collection_name='servers'))
+        resources.append(res)
+
+        return resources
 
=== modified file 'nova/api/openstack/extensions.py'
--- nova/api/openstack/extensions.py	2011-03-21 18:00:39 +0000
+++ nova/api/openstack/extensions.py	2011-04-12 11:01:25 +0000
@@ -1,6 +1,7 @@
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2011 OpenStack LLC.
+# Copyright 2011 Justin Santa Barbara
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -16,15 +17,18 @@
 #    under the License.
 
 import imp
+import inspect
 import os
 import sys
 import routes
 import webob.dec
 import webob.exc
 
+from nova import exception
 from nova import flags
 from nova import log as logging
 from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import faults
 
 
@@ -34,7 +38,85 @@
 FLAGS = flags.FLAGS
 
 
-class ActionExtensionController(wsgi.Controller):
+class ExtensionDescriptor(object):
+    """Base class that defines the contract for extensions.
+
+    Note that you don't have to derive from this class to have a valid
+    extension; it is purely a convenience.
+
+    """
+
+    def get_name(self):
+        """The name of the extension.
+
+        e.g. 'Fox In Socks'
+
+        """
+        raise NotImplementedError()
+
+    def get_alias(self):
+        """The alias for the extension.
+
+        e.g. 'FOXNSOX'
+
+        """
+        raise NotImplementedError()
+
+    def get_description(self):
+        """Friendly description for the extension.
+
+        e.g. 'The Fox In Socks Extension'
+
+        """
+        raise NotImplementedError()
+
+    def get_namespace(self):
+        """The XML namespace for the extension.
+
+        e.g. 'http://www.fox.in.socks/api/ext/pie/v1.0'
+
+        """
+        raise NotImplementedError()
+
+    def get_updated(self):
+        """The timestamp when the extension was last updated.
+
+        e.g. '2011-01-22T13:25:27-06:00'
+
+        """
+        # NOTE(justinsb): Not sure of the purpose of this is, vs the XML NS
+        raise NotImplementedError()
+
+    def get_resources(self):
+        """List of extensions.ResourceExtension extension objects.
+
+        Resources define new nouns, and are accessible through URLs.
+
+        """
+        resources = []
+        return resources
+
+    def get_actions(self):
+        """List of extensions.ActionExtension extension objects.
+
+        Actions are verbs callable from the API.
+
+        """
+        actions = []
+        return actions
+
+    def get_response_extensions(self):
+        """List of extensions.ResponseExtension extension objects.
+
+        Response extensions are used to insert information into existing
+        response data.
+
+        """
+        response_exts = []
+        return response_exts
+
+
+class ActionExtensionController(common.OpenstackController):
 
     def __init__(self, application):
 
@@ -55,7 +137,7 @@
         return res
 
 
-class ResponseExtensionController(wsgi.Controller):
+class ResponseExtensionController(common.OpenstackController):
 
     def __init__(self, application):
         self.application = application
@@ -74,7 +156,8 @@
                 body = res.body
                 headers = res.headers
             except AttributeError:
-                body = self._serialize(res, content_type)
+                default_xmlns = None
+                body = self._serialize(res, content_type, default_xmlns)
                 headers = {"Content-Type": content_type}
             res = webob.Response()
             res.body = body
@@ -82,7 +165,7 @@
         return res
 
 
-class ExtensionController(wsgi.Controller):
+class ExtensionController(common.OpenstackController):
 
     def __init__(self, extension_manager):
         self.extension_manager = extension_manager
@@ -94,45 +177,38 @@
         ext_data['description'] = ext.get_description()
         ext_data['namespace'] = ext.get_namespace()
         ext_data['updated'] = ext.get_updated()
-        ext_data['links'] = []  # TODO: implement extension links
+        ext_data['links'] = []  # TODO(dprince): implement extension links
         return ext_data
 
     def index(self, req):
         extensions = []
-        for alias, ext in self.extension_manager.extensions.iteritems():
+        for _alias, ext in self.extension_manager.extensions.iteritems():
             extensions.append(self._translate(ext))
         return dict(extensions=extensions)
 
     def show(self, req, id):
-        # NOTE: the extensions alias is used as the 'id' for show
+        # NOTE(dprince): the extensions alias is used as the 'id' for show
         ext = self.extension_manager.extensions[id]
         return self._translate(ext)
 
     def delete(self, req, id):
-        raise faults.Fault(exc.HTTPNotFound())
+        raise faults.Fault(webob.exc.HTTPNotFound())
 
     def create(self, req):
-        raise faults.Fault(exc.HTTPNotFound())
-
-    def delete(self, req, id):
-        raise faults.Fault(exc.HTTPNotFound())
+        raise faults.Fault(webob.exc.HTTPNotFound())
 
 
 class ExtensionMiddleware(wsgi.Middleware):
-    """
-    Extensions middleware that intercepts configured routes for extensions.
-    """
+    """Extensions middleware for WSGI."""
     @classmethod
     def factory(cls, global_config, **local_config):
-        """ paste factory """
+        """Paste factory."""
         def _factory(app):
             return cls(app, **local_config)
         return _factory
 
     def _action_ext_controllers(self, application, ext_mgr, mapper):
-        """
-        Return a dict of ActionExtensionController objects by collection
-        """
+        """Return a dict of ActionExtensionController-s by collection."""
         action_controllers = {}
         for action in ext_mgr.get_actions():
             if not action.collection in action_controllers.keys():
@@ -151,9 +227,7 @@
         return action_controllers
 
     def _response_ext_controllers(self, application, ext_mgr, mapper):
-        """
-        Return a dict of ResponseExtensionController objects by collection
-        """
+        """Returns a dict of ResponseExtensionController-s by collection."""
         response_ext_controllers = {}
         for resp_ext in ext_mgr.get_response_extensions():
             if not resp_ext.key in response_ext_controllers.keys():
@@ -212,18 +286,18 @@
 
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def __call__(self, req):
-        """
-        Route the incoming request with router.
-        """
+        """Route the incoming request with router."""
         req.environ['extended.app'] = self.application
         return self._router
 
     @staticmethod
     @webob.dec.wsgify(RequestClass=wsgi.Request)
     def _dispatch(req):
-        """
+        """Dispatch the request.
+
         Returns the routed WSGI app's response or defers to the extended
         application.
+
         """
         match = req.environ['wsgiorg.routing_args'][1]
         if not match:
@@ -233,10 +307,11 @@
 
 
 class ExtensionManager(object):
-    """
-    Load extensions from the configured extension path.
-    See nova/tests/api/openstack/extensions/foxinsocks.py for an example
-    extension implementation.
+    """Load extensions from the configured extension path.
+
+    See nova/tests/api/openstack/extensions/foxinsocks/extension.py for an
+    example extension implementation.
+
     """
 
     def __init__(self, path):
@@ -244,12 +319,10 @@
 
         self.path = path
         self.extensions = {}
-        self._load_extensions()
+        self._load_all_extensions()
 
     def get_resources(self):
-        """
-        returns a list of ResourceExtension objects
-        """
+        """Returns a list of ResourceExtension objects."""
         resources = []
         resources.append(ResourceExtension('extensions',
                                             ExtensionController(self)))
@@ -257,40 +330,37 @@
             try:
                 resources.extend(ext.get_resources())
             except AttributeError:
-                # NOTE: Extension aren't required to have resource extensions
+                # NOTE(dprince): Extension aren't required to have resource
+                # extensions
                 pass
         return resources
 
     def get_actions(self):
-        """
-        returns a list of ActionExtension objects
-        """
+        """Returns a list of ActionExtension objects."""
         actions = []
         for alias, ext in self.extensions.iteritems():
             try:
                 actions.extend(ext.get_actions())
             except AttributeError:
-                # NOTE: Extension aren't required to have action extensions
+                # NOTE(dprince): Extension aren't required to have action
+                # extensions
                 pass
         return actions
 
     def get_response_extensions(self):
-        """
-        returns a list of ResponseExtension objects
-        """
+        """Returns a list of ResponseExtension objects."""
         response_exts = []
         for alias, ext in self.extensions.iteritems():
             try:
                 response_exts.extend(ext.get_response_extensions())
             except AttributeError:
-                # NOTE: Extension aren't required to have response extensions
+                # NOTE(dprince): Extension aren't required to have response
+                # extensions
                 pass
         return response_exts
 
     def _check_extension(self, extension):
-        """
-        Checks for required methods in extension objects.
-        """
+        """Checks for required methods in extension objects."""
         try:
             LOG.debug(_('Ext name: %s'), extension.get_name())
             LOG.debug(_('Ext alias: %s'), extension.get_alias())
@@ -300,40 +370,59 @@
         except AttributeError as ex:
             LOG.exception(_("Exception loading extension: %s"), unicode(ex))
 
-    def _load_extensions(self):
-        """
+    def _load_all_extensions(self):
+        """Load extensions from the configured path.
+
         Load extensions from the configured path. The extension name is
         constructed from the module_name. If your extension module was named
         widgets.py the extension class within that module should be
         'Widgets'.
 
+        In addition, extensions are loaded from the 'contrib' directory.
+
         See nova/tests/api/openstack/extensions/foxinsocks.py for an example
         extension implementation.
+
         """
-        if not os.path.exists(self.path):
-            return
-
-        for f in os.listdir(self.path):
+        if os.path.exists(self.path):
+            self._load_all_extensions_from_path(self.path)
+
+        contrib_path = os.path.join(os.path.dirname(__file__), "contrib")
+        if os.path.exists(contrib_path):
+            self._load_all_extensions_from_path(contrib_path)
+
+    def _load_all_extensions_from_path(self, path):
+        for f in os.listdir(path):
             LOG.audit(_('Loading extension file: %s'), f)
             mod_name, file_ext = os.path.splitext(os.path.split(f)[-1])
-            ext_path = os.path.join(self.path, f)
-            if file_ext.lower() == '.py':
+            ext_path = os.path.join(path, f)
+            if file_ext.lower() == '.py' and not mod_name.startswith('_'):
                 mod = imp.load_source(mod_name, ext_path)
                 ext_name = mod_name[0].upper() + mod_name[1:]
-                try:
-                    new_ext = getattr(mod, ext_name)()
-                    self._check_extension(new_ext)
-                    self.extensions[new_ext.get_alias()] = new_ext
-                except AttributeError as ex:
-                    LOG.exception(_("Exception loading extension: %s"),
-                                   unicode(ex))
+                new_ext_class = getattr(mod, ext_name, None)
+                if not new_ext_class:
+                    LOG.warn(_('Did not find expected name '
+                               '"%(ext_name)s" in %(file)s'),
+                             {'ext_name': ext_name,
+                              'file': ext_path})
+                    continue
+                new_ext = new_ext_class()
+                self._check_extension(new_ext)
+                self._add_extension(new_ext)
+
+    def _add_extension(self, ext):
+        alias = ext.get_alias()
+        LOG.audit(_('Loaded extension: %s'), alias)
+
+        self._check_extension(ext)
+
+        if alias in self.extensions:
+            raise exception.Error("Found duplicate extension: %s" % alias)
+        self.extensions[alias] = ext
 
 
 class ResponseExtension(object):
-    """
-    ResponseExtension objects can be used to add data to responses from
-    core nova OpenStack API controllers.
-    """
+    """Add data to responses from core nova OpenStack API controllers."""
 
     def __init__(self, method, url_route, handler):
         self.url_route = url_route
@@ -343,10 +432,7 @@
 
 
 class ActionExtension(object):
-    """
-    ActionExtension objects can be used to add custom actions to core nova
-    nova OpenStack API controllers.
-    """
+    """Add custom actions to core nova OpenStack API controllers."""
 
     def __init__(self, collection, action_name, handler):
         self.collection = collection
@@ -355,10 +441,7 @@
 
 
 class ResourceExtension(object):
-    """
-    ResourceExtension objects can be used to add top level resources
-    to the OpenStack API in nova.
-    """
+    """Add top level resources to the OpenStack API in nova."""
 
     def __init__(self, collection, controller, parent=None,
                  collection_actions={}, member_actions={}):
 
=== modified file 'nova/api/openstack/faults.py'
--- nova/api/openstack/faults.py	2011-03-17 20:26:52 +0000
+++ nova/api/openstack/faults.py	2011-04-12 11:01:25 +0000
@@ -20,10 +20,10 @@
 import webob.exc
 
 from nova import wsgi
+from nova.api.openstack import common
 
 
 class Fault(webob.exc.HTTPException):
-
     """An RS API fault response."""
 
     _fault_names = {
@@ -47,7 +47,7 @@
         """Generate a WSGI response based on the exception passed to ctor."""
         # Replace the body with fault details.
         code = self.wrapped_exc.status_int
-        fault_name = self._fault_names.get(code, "computeFault")
+        fault_name = self._fault_names.get(code, "cloudServersFault")
         fault_data = {
             fault_name: {
                 'code': code,
@@ -57,9 +57,11 @@
             fault_data[fault_name]['retryAfter'] = retry
         # 'code' is an attribute on the fault tag itself
         metadata = {'application/xml': {'attributes': {fault_name: 'code'}}}
-        serializer = wsgi.Serializer(metadata)
+        default_xmlns = common.XML_NS_V10
+        serializer = wsgi.Serializer(metadata, default_xmlns)
         content_type = req.best_match_content_type()
         self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
+        self.wrapped_exc.content_type = content_type
         return self.wrapped_exc
 
 
 
=== modified file 'nova/api/openstack/flavors.py'
--- nova/api/openstack/flavors.py	2011-03-24 16:46:39 +0000
+++ nova/api/openstack/flavors.py	2011-04-12 11:01:25 +0000
@@ -19,11 +19,11 @@
 
 from nova import db
 from nova import exception
-from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import views
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
     """Flavor controller for the OpenStack API."""
 
     _serialization_metadata = {
@@ -76,3 +76,6 @@
     def _get_view_builder(self, req):
         base_url = req.application_url
         return views.flavors.ViewBuilderV11(base_url)
+
+    def get_default_xmlns(self, req):
+        return common.XML_NS_V11
 
=== modified file 'nova/api/openstack/image_metadata.py'
--- nova/api/openstack/image_metadata.py	2011-03-25 14:07:42 +0000
+++ nova/api/openstack/image_metadata.py	2011-04-12 11:01:25 +0000
@@ -18,15 +18,17 @@
 from webob import exc
 
 from nova import flags
+from nova import quota
 from nova import utils
 from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import faults
 
 
 FLAGS = flags.FLAGS
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
     """The image metadata API controller for the Openstack API"""
 
     def __init__(self):
@@ -39,6 +41,15 @@
         metadata = image.get('properties', {})
         return metadata
 
+    def _check_quota_limit(self, context, metadata):
+        if metadata is None:
+            return
+        num_metadata = len(metadata)
+        quota_metadata = quota.allowed_metadata_items(context, num_metadata)
+        if quota_metadata < num_metadata:
+            expl = _("Image metadata limit exceeded")
+            raise exc.HTTPBadRequest(explanation=expl)
+
     def index(self, req, image_id):
         """Returns the list of metadata for a given instance"""
         context = req.environ['nova.context']
@@ -61,6 +72,7 @@
         if 'metadata' in body:
             for key, value in body['metadata'].iteritems():
                 metadata[key] = value
+        self._check_quota_limit(context, metadata)
         img['properties'] = metadata
         self.image_service.update(context, image_id, img, None)
         return dict(metadata=metadata)
@@ -77,6 +89,7 @@
         img = self.image_service.show(context, image_id)
         metadata = self._get_metadata(context, image_id, img)
         metadata[id] = body[id]
+        self._check_quota_limit(context, metadata)
         img['properties'] = metadata
         self.image_service.update(context, image_id, img, None)
 
 
=== modified file 'nova/api/openstack/images.py'
--- nova/api/openstack/images.py	2011-03-24 21:13:55 +0000
+++ nova/api/openstack/images.py	2011-04-12 11:01:25 +0000
@@ -1,6 +1,4 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright 2010 OpenStack LLC.
+# Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
 #    Licensed under the Apache License, Version 2.0 (the "License"); you may
@@ -15,248 +13,143 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import datetime
-
-from webob import exc
+import webob.exc
 
 from nova import compute
 from nova import exception
 from nova import flags
 from nova import log
 from nova import utils
-from nova import wsgi
-import nova.api.openstack
 from nova.api.openstack import common
 from nova.api.openstack import faults
-import nova.image.service
+from nova.api.openstack.views import images as images_view
 
 
 LOG = log.getLogger('nova.api.openstack.images')
-
 FLAGS = flags.FLAGS
 
 
-def _translate_keys(item):
-    """
-    Maps key names to Rackspace-like attributes for return
-    also pares down attributes to those we want
-    item is a dict
-
-    Note: should be removed when the set of keys expected by the api
-    and the set of keys returned by the image service are equivalent
-
-    """
-    # TODO(tr3buchet): this map is specific to s3 object store,
-    # replace with a list of keys for _filter_keys later
-    mapped_keys = {'status': 'imageState',
-                   'id': 'imageId',
-                   'name': 'imageLocation'}
-
-    mapped_item = {}
-    # TODO(tr3buchet):
-    # this chunk of code works with s3 and the local image service/glance
-    # when we switch to glance/local image service it can be replaced with
-    # a call to _filter_keys, and mapped_keys can be changed to a list
-    try:
-        for k, v in mapped_keys.iteritems():
-            # map s3 fields
-            mapped_item[k] = item[v]
-    except KeyError:
-        # return only the fields api expects
-        mapped_item = _filter_keys(item, mapped_keys.keys())
-
-    return mapped_item
-
-
-def _translate_status(item):
-    """
-    Translates status of image to match current Rackspace api bindings
-    item is a dict
-
-    Note: should be removed when the set of statuses expected by the api
-    and the set of statuses returned by the image service are equivalent
-
-    """
-    status_mapping = {
-        'pending': 'queued',
-        'decrypting': 'preparing',
-        'untarring': 'saving',
-        'available': 'active'}
-    try:
-        item['status'] = status_mapping[item['status']]
-    except KeyError:
-        # TODO(sirp): Performing translation of status (if necessary) here for
-        # now. Perhaps this should really be done in EC2 API and
-        # S3ImageService
-        pass
-
-
-def _filter_keys(item, keys):
-    """
-    Filters all model attributes except for keys
-    item is a dict
-
-    """
-    return dict((k, v) for k, v in item.iteritems() if k in keys)
-
-
-def _convert_image_id_to_hash(image):
-    if 'imageId' in image:
-        # Convert EC2-style ID (i-blah) to Rackspace-style (int)
-        image_id = abs(hash(image['imageId']))
-        image['imageId'] = image_id
-        image['id'] = image_id
-
-
-def _translate_s3_like_images(image_metadata):
-    """Work-around for leaky S3ImageService abstraction"""
-    api_metadata = image_metadata.copy()
-    _convert_image_id_to_hash(api_metadata)
-    api_metadata = _translate_keys(api_metadata)
-    _translate_status(api_metadata)
-    return api_metadata
-
-
-def _translate_from_image_service_to_api(image_metadata):
-    """Translate from ImageService to OpenStack API style attribute names
-
-    This involves 4 steps:
-
-        1. Filter out attributes that the OpenStack API doesn't need
-
-        2. Translate from base image attributes from names used by
-           BaseImageService to names used by OpenStack API
-
-        3. Add in any image properties
-
-        4. Format values according to API spec (for example dates must
-           look like "2010-08-10T12:00:00Z")
-    """
-    service_metadata = image_metadata.copy()
-    properties = service_metadata.pop('properties', {})
-
-    # 1. Filter out unecessary attributes
-    api_keys = ['id', 'name', 'updated_at', 'created_at', 'status']
-    api_metadata = utils.subset_dict(service_metadata, api_keys)
-
-    # 2. Translate base image attributes
-    api_map = {'updated_at': 'updated', 'created_at': 'created'}
-    api_metadata = utils.map_dict_keys(api_metadata, api_map)
-
-    # 3. Add in any image properties
-    # 3a. serverId is used for backups and snapshots
-    try:
-        api_metadata['serverId'] = int(properties['instance_id'])
-    except KeyError:
-        pass  # skip if it's not present
-    except ValueError:
-        pass  # skip if it's not an integer
-
-    # 3b. Progress special case
-    # TODO(sirp): ImageService doesn't have a notion of progress yet, so for
-    # now just fake it
-    if service_metadata['status'] == 'saving':
-        api_metadata['progress'] = 0
-
-    # 4. Format values
-    # 4a. Format Image Status (API requires uppercase)
-    api_metadata['status'] = _format_status_for_api(api_metadata['status'])
-
-    # 4b. Format timestamps
-    for attr in ('created', 'updated'):
-        if attr in api_metadata:
-            api_metadata[attr] = _format_datetime_for_api(
-                api_metadata[attr])
-
-    return api_metadata
-
-
-def _format_status_for_api(status):
-    """Return status in a format compliant with OpenStack API"""
-    mapping = {'queued': 'QUEUED',
-               'preparing': 'PREPARING',
-               'saving': 'SAVING',
-               'active': 'ACTIVE',
-               'killed': 'FAILED'}
-    return mapping[status]
-
-
-def _format_datetime_for_api(datetime_):
-    """Stringify datetime objects in a format compliant with OpenStack API"""
-    API_DATETIME_FMT = '%Y-%m-%dT%H:%M:%SZ'
-    return datetime_.strftime(API_DATETIME_FMT)
-
-
-def _safe_translate(image_metadata):
-    """Translate attributes for OpenStack API, temporary workaround for
-    S3ImageService attribute leakage.
-    """
-    # FIXME(sirp): The S3ImageService appears to be leaking implementation
-    # details, including its internal attribute names, and internal
-    # `status` values. Working around it for now.
-    s3_like_image = ('imageId' in image_metadata)
-    if s3_like_image:
-        translate = _translate_s3_like_images
-    else:
-        translate = _translate_from_image_service_to_api
-    return translate(image_metadata)
-
-
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
+    """Base `wsgi.Controller` for retrieving/displaying images."""
 
     _serialization_metadata = {
         'application/xml': {
             "attributes": {
                 "image": ["id", "name", "updated", "created", "status",
-                          "serverId", "progress"]}}}
-
-    def __init__(self):
-        self._service = utils.import_object(FLAGS.image_service)
+                          "serverId", "progress"],
+                "link": ["rel", "type", "href"],
+            },
+        },
+    }
+
+    def __init__(self, image_service=None, compute_service=None):
+        """Initialize new `ImageController`.
+
+        :param compute_service: `nova.compute.api:API`
+        :param image_service: `nova.image.service:BaseImageService`
+        """
+        _default_service = utils.import_object(flags.FLAGS.image_service)
+
+        self._compute_service = compute_service or compute.API()
+        self._image_service = image_service or _default_service
 
     def index(self, req):
-        """Return all public images in brief"""
+        """Return an index listing of images available to the request.
+
+        :param req: `wsgi.Request` object
+        """
         context = req.environ['nova.context']
-        image_metas = self._service.index(context)
-        image_metas = common.limited(image_metas, req)
-        return dict(images=image_metas)
+        images = self._image_service.index(context)
+        images = common.limited(images, req)
+        builder = self.get_builder(req).build
+        return dict(images=[builder(image, detail=False) for image in images])
 
     def detail(self, req):
-        """Return all public images in detail"""
+        """Return a detailed index listing of images available to the request.
+
+        :param req: `wsgi.Request` object.
+        """
         context = req.environ['nova.context']
-        image_metas = self._service.detail(context)
-        image_metas = common.limited(image_metas, req)
-        api_image_metas = [_safe_translate(image_meta)
-                           for image_meta in image_metas]
-        return dict(images=api_image_metas)
+        images = self._image_service.detail(context)
+        images = common.limited(images, req)
+        builder = self.get_builder(req).build
+        return dict(images=[builder(image, detail=True) for image in images])
 
     def show(self, req, id):
-        """Return data about the given image id"""
+        """Return detailed information about a specific image.
+
+        :param req: `wsgi.Request` object
+        :param id: Image identifier (integer)
+        """
         context = req.environ['nova.context']
-        try:
-            image_id = common.get_image_id_from_image_hash(
-                self._service, context, id)
+
+        try:
+            image_id = int(id)
+        except ValueError:
+            explanation = _("Image not found.")
+            raise faults.Fault(webob.exc.HTTPNotFound(explanation=explanation))
+
+        try:
+            image = self._image_service.show(context, image_id)
         except exception.NotFound:
-            raise faults.Fault(exc.HTTPNotFound())
+            explanation = _("Image '%d' not found.") % (image_id)
+            raise faults.Fault(webob.exc.HTTPNotFound(explanation=explanation))
 
-        image_meta = self._service.show(context, image_id)
-        api_image_meta = _safe_translate(image_meta)
-        return dict(image=api_image_meta)
+        return dict(image=self.get_builder(req).build(image, detail=True))
 
     def delete(self, req, id):
-        # Only public images are supported for now.
-        raise faults.Fault(exc.HTTPNotFound())
+        """Delete an image, if allowed.
+
+        :param req: `wsgi.Request` object
+        :param id: Image identifier (integer)
+        """
+        image_id = id
+        context = req.environ['nova.context']
+        self._image_service.delete(context, image_id)
+        return webob.exc.HTTPNoContent()
 
     def create(self, req):
+        """Snapshot a server instance and save the image.
+
+        :param req: `wsgi.Request` object
+        """
         context = req.environ['nova.context']
-        env = self._deserialize(req.body, req.get_content_type())
-        instance_id = env["image"]["serverId"]
-        name = env["image"]["name"]
-        image_meta = compute.API().snapshot(
-            context, instance_id, name)
-        api_image_meta = _safe_translate(image_meta)
-        return dict(image=api_image_meta)
-
-    def update(self, req, id):
-        # Users may not modify public images, and that's all that
-        # we support for now.
-        raise faults.Fault(exc.HTTPNotFound())
+        content_type = req.get_content_type()
+        image = self._deserialize(req.body, content_type)
+
+        if not image:
+            raise webob.exc.HTTPBadRequest()
+
+        try:
+            server_id = image["image"]["serverId"]
+            image_name = image["image"]["name"]
+        except KeyError:
+            raise webob.exc.HTTPBadRequest()
+
+        image = self._compute_service.snapshot(context, server_id, image_name)
+        return self.get_builder(req).build(image, detail=True)
+
+    def get_builder(self, request):
+        """Indicates that you must use a Controller subclass."""
+        raise NotImplementedError
+
+
+class ControllerV10(Controller):
+    """Version 1.0 specific controller logic."""
+
+    def get_builder(self, request):
+        """Property to get the ViewBuilder class we need to use."""
+        base_url = request.application_url
+        return images_view.ViewBuilderV10(base_url)
+
+
+class ControllerV11(Controller):
+    """Version 1.1 specific controller logic."""
+
+    def get_builder(self, request):
+        """Property to get the ViewBuilder class we need to use."""
+        base_url = request.application_url
+        return images_view.ViewBuilderV11(base_url)
+
+    def get_default_xmlns(self, req):
+        return common.XML_NS_V11
 
=== added file 'nova/api/openstack/ips.py'
--- nova/api/openstack/ips.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/ips.py	2011-04-12 11:01:25 +0000
@@ -0,0 +1,72 @@
+# 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 time
+
+from webob import exc
+
+import nova
+import nova.api.openstack.views.addresses
+from nova.api.openstack import common
+from nova.api.openstack import faults
+
+
+class Controller(common.OpenstackController):
+    """The servers addresses API controller for the Openstack API."""
+
+    _serialization_metadata = {
+        'application/xml': {
+            'list_collections': {
+                'public':  {'item_name': 'ip', 'item_key': 'addr'},
+                'private': {'item_name': 'ip', 'item_key': 'addr'},
+            },
+        },
+    }
+
+    def __init__(self):
+        self.compute_api = nova.compute.API()
+        self.builder = nova.api.openstack.views.addresses.ViewBuilderV10()
+
+    def index(self, req, server_id):
+        try:
+            instance = self.compute_api.get(req.environ['nova.context'], id)
+        except nova.exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        return {'addresses': self.builder.build(instance)}
+
+    def public(self, req, server_id):
+        try:
+            instance = self.compute_api.get(req.environ['nova.context'], id)
+        except nova.exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        return {'public': self.builder.build_public_parts(instance)}
+
+    def private(self, req, server_id):
+        try:
+            instance = self.compute_api.get(req.environ['nova.context'], id)
+        except nova.exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        return {'private': self.builder.build_private_parts(instance)}
+
+    def show(self, req, server_id, id):
+        return faults.Fault(exc.HTTPNotImplemented())
+
+    def create(self, req, server_id):
+        return faults.Fault(exc.HTTPNotImplemented())
+
+    def delete(self, req, server_id, id):
+        return faults.Fault(exc.HTTPNotImplemented())
 
=== modified file 'nova/api/openstack/limits.py'
--- nova/api/openstack/limits.py	2011-03-17 20:26:52 +0000
+++ nova/api/openstack/limits.py	2011-04-12 11:01:25 +0000
@@ -31,8 +31,8 @@
 from webob.dec import wsgify
 
 from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import faults
-from nova.wsgi import Controller
 from nova.wsgi import Middleware
 
 
@@ -43,7 +43,7 @@
 PER_DAY = 60 * 60 * 24
 
 
-class LimitsController(Controller):
+class LimitsController(common.OpenstackController):
     """
     Controller for accessing limits in the OpenStack API.
     """
 
=== modified file 'nova/api/openstack/server_metadata.py'
--- nova/api/openstack/server_metadata.py	2011-03-22 14:01:18 +0000
+++ nova/api/openstack/server_metadata.py	2011-04-12 11:01:25 +0000
@@ -19,10 +19,11 @@
 
 from nova import compute
 from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import faults
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
     """ The server metadata API controller for the Openstack API """
 
     def __init__(self):
 
=== modified file 'nova/api/openstack/servers.py'
--- nova/api/openstack/servers.py	2011-03-28 08:27:17 +0000
+++ nova/api/openstack/servers.py	2011-04-12 11:01:25 +0000
@@ -44,7 +44,7 @@
 FLAGS = flags.FLAGS
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
     """ The Server API controller for the OpenStack API """
 
     _serialization_metadata = {
@@ -55,6 +55,13 @@
                            "imageRef", "vnics"],
                 "link": ["rel", "type", "href"],
             },
+            "dict_collections": {
+                "metadata": {"item_name": "meta", "item_key": "key"},
+            },
+            "list_collections": {
+                "public": {"item_name": "ip", "item_key": "addr"},
+                "private": {"item_name": "ip", "item_key": "addr"},
+            },
         },
     }
 
@@ -63,15 +70,6 @@
         self._image_service = utils.import_object(FLAGS.image_service)
         super(Controller, self).__init__()
 
-    def ips(self, req, id):
-        try:
-            instance = self.compute_api.get(req.environ['nova.context'], id)
-        except exception.NotFound:
-            return faults.Fault(exc.HTTPNotFound())
-
-        builder = self._get_addresses_view_builder(req)
-        return builder.build(instance)
-
     def index(self, req):
         """ Returns a list of server names and ids for a given user """
         return self._items(req, is_detail=False)
@@ -151,16 +149,27 @@
 
         vnics = [env['server']['vnics']] if 'vnics' in env['server'] else None
         flavor_id = self._flavor_id_from_req_data(env)
+
+        if not 'name' in env['server']:
+            msg = _("Server name is not defined")
+            return exc.HTTPBadRequest(msg)
+
+        name = env['server']['name']
+        self._validate_server_name(name)
+        name = name.strip()
+
         try:
+            inst_type = \
+                instance_types.get_instance_type_by_flavor_id(flavor_id)
             (inst,) = self.compute_api.create(
                 context,
-                instance_types.get_by_flavor_id(flavor_id),
+                inst_type,
                 image_id,
                 vnic_list=vnics,
                 kernel_id=kernel_id,
                 ramdisk_id=ramdisk_id,
-                display_name=env['server']['name'],
-                display_description=env['server']['name'],
+                display_name=name,
+                display_description=name,
                 key_name=key_name,
                 key_data=key_data,
                 metadata=metadata,
@@ -168,13 +177,12 @@
         except quota.QuotaError as error:
             self._handle_quota_error(error)
 
-        inst['instance_type'] = flavor_id
+        inst['instance_type'] = inst_type
         inst['image_id'] = requested_image_id
 
         builder = self._get_view_builder(req)
         server = builder.build(inst, is_detail=True)
-        password = "%s%s" % (server['server']['name'][:4],
-                             utils.generate_password(12))
+        password = utils.generate_password(16)
         server['server']['adminPass'] = password
         self.compute_api.set_admin_password(context, server['server']['id'],
                                             password)
@@ -248,31 +256,45 @@
 
         ctxt = req.environ['nova.context']
         update_dict = {}
-        if 'adminPass' in inst_dict['server']:
-            update_dict['admin_pass'] = inst_dict['server']['adminPass']
-            try:
-                self.compute_api.set_admin_password(ctxt, id)
-            except exception.TimeoutException:
-                return exc.HTTPRequestTimeout()
+
         if 'name' in inst_dict['server']:
-            update_dict['display_name'] = inst_dict['server']['name']
+            name = inst_dict['server']['name']
+            self._validate_server_name(name)
+            update_dict['display_name'] = name.strip()
+
+        self._parse_update(ctxt, id, inst_dict, update_dict)
+
         try:
             self.compute_api.update(ctxt, id, **update_dict)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
+
         return exc.HTTPNoContent()
 
+    def _validate_server_name(self, value):
+        if not isinstance(value, basestring):
+            msg = _("Server name is not a string or unicode")
+            raise exc.HTTPBadRequest(msg)
+
+        if value.strip() == '':
+            msg = _("Server name is an empty string")
+            raise exc.HTTPBadRequest(msg)
+
+    def _parse_update(self, context, id, inst_dict, update_dict):
+        pass
+
     @scheduler_api.redirect_handler
     def action(self, req, id):
         """Multi-purpose method used to reboot, rebuild, or
         resize a server"""
 
         actions = {
-            'reboot':        self._action_reboot,
-            'resize':        self._action_resize,
+            'changePassword': self._action_change_password,
+            'reboot': self._action_reboot,
+            'resize': self._action_resize,
             'confirmResize': self._action_confirm_resize,
-            'revertResize':  self._action_revert_resize,
-            'rebuild':       self._action_rebuild,
+            'revertResize': self._action_revert_resize,
+            'rebuild': self._action_rebuild,
             }
 
         input_dict = self._deserialize(req.body, req.get_content_type())
@@ -281,6 +303,9 @@
                 return actions[key](input_dict, req, id)
         return faults.Fault(exc.HTTPNotImplemented())
 
+    def _action_change_password(self, input_dict, req, id):
+        return exc.HTTPNotImplemented()
+
     def _action_confirm_resize(self, input_dict, req, id):
         try:
             self.compute_api.confirm_resize(req.environ['nova.context'], id)
@@ -479,7 +504,7 @@
 
     @scheduler_api.redirect_handler
     def get_ajax_console(self, req, id):
-        """ Returns a url to an instance's ajaxterm console. """
+        """Returns a url to an instance's ajaxterm console."""
         try:
             self.compute_api.get_ajax_console(req.environ['nova.context'],
                 int(id))
@@ -488,6 +513,16 @@
         return exc.HTTPAccepted()
 
     @scheduler_api.redirect_handler
+    def get_vnc_console(self, req, id):
+        """Returns a url to an instance's ajaxterm console."""
+        try:
+            self.compute_api.get_vnc_console(req.environ['nova.context'],
+                                             int(id))
+        except exception.NotFound:
+            return faults.Fault(exc.HTTPNotFound())
+        return exc.HTTPAccepted()
+
+    @scheduler_api.redirect_handler
     def diagnostics(self, req, id):
         """Permit Admins to retrieve server diagnostics."""
         ctxt = req.environ["nova.context"]
@@ -532,7 +567,7 @@
                 _("Cannot build from image %(image_id)s, status not active") %
                   locals())
 
-        if image_meta['properties']['disk_format'] != 'ami':
+        if image_meta.get('container_format') != 'ami':
             return None, None
 
         try:
@@ -568,6 +603,14 @@
     def _limit_items(self, items, req):
         return common.limited(items, req)
 
+    def _parse_update(self, context, server_id, inst_dict, update_dict):
+        if 'adminPass' in inst_dict['server']:
+            update_dict['admin_pass'] = inst_dict['server']['adminPass']
+            try:
+                self.compute_api.set_admin_password(context, server_id)
+            except exception.TimeoutException:
+                return exc.HTTPRequestTimeout()
+
 
 class ControllerV11(Controller):
     def _image_id_from_req_data(self, data):
@@ -591,9 +634,25 @@
     def _get_addresses_view_builder(self, req):
         return nova.api.openstack.views.addresses.ViewBuilderV11(req)
 
+    def _action_change_password(self, input_dict, req, id):
+        context = req.environ['nova.context']
+        if (not 'changePassword' in input_dict
+            or not 'adminPass' in input_dict['changePassword']):
+            msg = _("No adminPass was specified")
+            return exc.HTTPBadRequest(msg)
+        password = input_dict['changePassword']['adminPass']
+        if not isinstance(password, basestring) or password == '':
+            msg = _("Invalid adminPass")
+            return exc.HTTPBadRequest(msg)
+        self.compute_api.set_admin_password(context, id, password)
+        return exc.HTTPAccepted()
+
     def _limit_items(self, items, req):
         return common.limited_by_marker(items, req)
 
+    def get_default_xmlns(self, req):
+        return common.XML_NS_V11
+
 
 class ServerCreateRequestXMLDeserializer(object):
     """
 
=== modified file 'nova/api/openstack/shared_ip_groups.py'
--- nova/api/openstack/shared_ip_groups.py	2011-03-09 18:10:45 +0000
+++ nova/api/openstack/shared_ip_groups.py	2011-04-12 11:01:25 +0000
@@ -17,7 +17,7 @@
 
 from webob import exc
 
-from nova import wsgi
+from nova.api.openstack import common
 from nova.api.openstack import faults
 
 
@@ -32,7 +32,7 @@
     return dict(sharedIpGroups=inst)
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
     """ The Shared IP Groups Controller for the Openstack API """
 
     _serialization_metadata = {
@@ -42,11 +42,11 @@
 
     def index(self, req):
         """ Returns a list of Shared IP Groups for the user """
-        return dict(sharedIpGroups=[])
+        raise faults.Fault(exc.HTTPNotImplemented())
 
     def show(self, req, id):
         """ Shows in-depth information on a specific Shared IP Group """
-        return _translate_keys({})
+        raise faults.Fault(exc.HTTPNotImplemented())
 
     def update(self, req, id):
         """ You can't update a Shared IP Group """
@@ -58,7 +58,7 @@
 
     def detail(self, req):
         """ Returns a complete list of Shared IP Groups """
-        return _translate_detail_keys({})
+        raise faults.Fault(exc.HTTPNotImplemented())
 
     def create(self, req):
         """ Creates a new Shared IP group """
 
=== modified file 'nova/api/openstack/users.py'
--- nova/api/openstack/users.py	2011-03-16 19:15:57 +0000
+++ nova/api/openstack/users.py	2011-04-12 11:01:25 +0000
@@ -18,7 +18,6 @@
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import wsgi
 from nova.api.openstack import common
 from nova.api.openstack import faults
 from nova.auth import manager
@@ -35,7 +34,7 @@
                 admin=user.admin)
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
 
     _serialization_metadata = {
         'application/xml': {
 
=== modified file 'nova/api/openstack/versions.py'
--- nova/api/openstack/versions.py	2011-03-22 18:09:23 +0000
+++ nova/api/openstack/versions.py	2011-04-12 11:01:25 +0000
@@ -15,8 +15,8 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+import webob
 import webob.dec
-import webob.exc
 
 from nova import wsgi
 import nova.api.openstack.views.versions
@@ -51,4 +51,10 @@
         }
 
         content_type = req.best_match_content_type()
-        return wsgi.Serializer(metadata).serialize(response, content_type)
+        body = wsgi.Serializer(metadata).serialize(response, content_type)
+
+        response = webob.Response()
+        response.content_type = content_type
+        response.body = body
+
+        return response
 
=== modified file 'nova/api/openstack/views/addresses.py'
--- nova/api/openstack/views/addresses.py	2011-03-17 07:21:09 +0000
+++ nova/api/openstack/views/addresses.py	2011-04-12 11:01:25 +0000
@@ -28,10 +28,16 @@
 
 class ViewBuilderV10(ViewBuilder):
     def build(self, inst):
-        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
-        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        private_ips = self.build_private_parts(inst)
+        public_ips = self.build_public_parts(inst)
         return dict(public=public_ips, private=private_ips)
 
+    def build_public_parts(self, inst):
+        return utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+
+    def build_private_parts(self, inst):
+        return utils.get_from_path(inst, 'fixed_ip/address')
+
 
 class ViewBuilderV11(ViewBuilder):
     def build(self, inst):
 
=== modified file 'nova/api/openstack/views/images.py'
--- nova/api/openstack/views/images.py	2011-03-17 07:41:01 +0000
+++ nova/api/openstack/views/images.py	2011-04-12 11:01:25 +0000
@@ -15,20 +15,100 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from nova.api.openstack import common
+import os.path
 
 
 class ViewBuilder(object):
-    def __init__(self):
-        pass
-
-    def build(self, image_obj):
-        raise NotImplementedError()
-
-
-class ViewBuilderV11(ViewBuilder):
+    """Base class for generating responses to OpenStack API image requests."""
+
     def __init__(self, base_url):
-        self.base_url = base_url
+        """Initialize new `ViewBuilder`."""
+        self._url = base_url
+
+    def _format_dates(self, image):
+        """Update all date fields to ensure standardized formatting."""
+        for attr in ['created_at', 'updated_at', 'deleted_at']:
+            if image.get(attr) is not None:
+                image[attr] = image[attr].strftime('%Y-%m-%dT%H:%M:%SZ')
+
+    def _format_status(self, image):
+        """Update the status field to standardize format."""
+        status_mapping = {
+            'pending': 'QUEUED',
+            'decrypting': 'PREPARING',
+            'untarring': 'SAVING',
+            'available': 'ACTIVE',
+            'killed': 'FAILED',
+        }
+
+        try:
+            image['status'] = status_mapping[image['status']].upper()
+        except KeyError:
+            image['status'] = image['status'].upper()
 
     def generate_href(self, image_id):
-        return "%s/images/%s" % (self.base_url, image_id)
+        """Return an href string pointing to this object."""
+        return os.path.join(self._url, "images", str(image_id))
+
+    def build(self, image_obj, detail=False):
+        """Return a standardized image structure for display by the API."""
+        properties = image_obj.get("properties", {})
+
+        self._format_dates(image_obj)
+
+        if "status" in image_obj:
+            self._format_status(image_obj)
+
+        image = {
+            "id": image_obj.get("id"),
+            "name": image_obj.get("name"),
+        }
+
+        if "instance_id" in properties:
+            try:
+                image["serverId"] = int(properties["instance_id"])
+            except ValueError:
+                pass
+
+        if detail:
+            image.update({
+                "created": image_obj.get("created_at"),
+                "updated": image_obj.get("updated_at"),
+                "status": image_obj.get("status"),
+            })
+
+            if image["status"] == "SAVING":
+                image["progress"] = 0
+
+        return image
+
+
+class ViewBuilderV10(ViewBuilder):
+    """OpenStack API v1.0 Image Builder"""
+    pass
+
+
+class ViewBuilderV11(ViewBuilder):
+    """OpenStack API v1.1 Image Builder"""
+
+    def build(self, image_obj, detail=False):
+        """Return a standardized image structure for display by the API."""
+        image = ViewBuilder.build(self, image_obj, detail)
+        href = self.generate_href(image_obj["id"])
+
+        image["links"] = [{
+            "rel": "self",
+            "href": href,
+        },
+        {
+            "rel": "bookmark",
+            "type": "application/json",
+            "href": href,
+        },
+        {
+            "rel": "bookmark",
+            "type": "application/xml",
+            "href": href,
+        }]
+
+        return image
 
=== modified file 'nova/api/openstack/views/servers.py'
--- nova/api/openstack/views/servers.py	2011-03-24 14:15:50 +0000
+++ nova/api/openstack/views/servers.py	2011-04-12 11:01:25 +0000
@@ -57,16 +57,16 @@
     def _build_detail(self, inst):
         """Returns a detailed model of a server."""
         power_mapping = {
-            None: 'build',
-            power_state.NOSTATE: 'build',
-            power_state.RUNNING: 'active',
-            power_state.BLOCKED: 'active',
-            power_state.SUSPENDED: 'suspended',
-            power_state.PAUSED: 'paused',
-            power_state.SHUTDOWN: 'active',
-            power_state.SHUTOFF: 'active',
-            power_state.CRASHED: 'error',
-            power_state.FAILED: 'error'}
+            None: 'BUILD',
+            power_state.NOSTATE: 'BUILD',
+            power_state.RUNNING: 'ACTIVE',
+            power_state.BLOCKED: 'ACTIVE',
+            power_state.SUSPENDED: 'SUSPENDED',
+            power_state.PAUSED: 'PAUSED',
+            power_state.SHUTDOWN: 'ACTIVE',
+            power_state.SHUTOFF: 'ACTIVE',
+            power_state.CRASHED: 'ERROR',
+            power_state.FAILED: 'ERROR'}
 
         inst_dict = {
             'id': int(inst['id']),
@@ -77,12 +77,12 @@
         ctxt = nova.context.get_admin_context()
         compute_api = nova.compute.API()
         if compute_api.has_finished_migration(ctxt, inst['id']):
-            inst_dict['status'] = 'resize-confirm'
+            inst_dict['status'] = 'RESIZE-CONFIRM'
 
         # Return the metadata as a dictionary
         metadata = {}
         for item in inst.get('metadata', []):
-            metadata[item['key']] = item['value']
+            metadata[item['key']] = str(item['value'])
         inst_dict['metadata'] = metadata
 
         inst_dict['hostId'] = ''
@@ -115,7 +115,7 @@
 
     def _build_flavor(self, response, inst):
         if 'instance_type' in dict(inst):
-            response['flavorId'] = inst['instance_type']
+            response['flavorId'] = inst['instance_type']['flavorid']
 
 
 class ViewBuilderV11(ViewBuilder):
@@ -134,7 +134,7 @@
 
     def _build_flavor(self, response, inst):
         if "instance_type" in dict(inst):
-            flavor_id = inst["instance_type"]
+            flavor_id = inst["instance_type"]['flavorid']
             flavor_ref = self.flavor_builder.generate_href(flavor_id)
             response["flavorRef"] = flavor_ref
 
 
=== modified file 'nova/api/openstack/zones.py'
--- nova/api/openstack/zones.py	2011-03-24 19:04:24 +0000
+++ nova/api/openstack/zones.py	2011-04-12 11:01:25 +0000
@@ -13,12 +13,10 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import common
-
 from nova import db
 from nova import flags
 from nova import log as logging
-from nova import wsgi
+from nova.api.openstack import common
 from nova.scheduler import api
 
 
@@ -43,7 +41,7 @@
                     'deleted', 'deleted_at', 'updated_at'))
 
 
-class Controller(wsgi.Controller):
+class Controller(common.OpenstackController):
 
     _serialization_metadata = {
         'application/xml': {
 
=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-04-07 11:20:06 +0000
+++ nova/compute/api.py	2011-04-12 11:01:25 +0000
@@ -38,8 +38,12 @@
 from nova.db import base
 from nova.network import service as net_service
 
+
+LOG = logging.getLogger('nova.compute.api')
+
+
 FLAGS = flags.FLAGS
-LOG = logging.getLogger('nova.compute.api')
+flags.DECLARE('vncproxy_topic', 'nova.vnc')
 
 def generate_default_hostname(instance_id):
     """Default function to generate a hostname given an instance reference."""
@@ -107,8 +111,11 @@
         """Create the number of instances requested if quota and
         other arguments check out ok."""
 
-        type_data = instance_types.get_instance_type(instance_type)
-        num_instances = quota.allowed_instances(context, max_count, type_data)
+        if not instance_type:
+            instance_type = instance_types.get_default_instance_type()
+
+        num_instances = quota.allowed_instances(context, max_count,
+                                                instance_type)
         if num_instances < min_count:
             pid = context.project_id
             LOG.warn(_("Quota exceeeded for %(pid)s,"
@@ -194,10 +201,10 @@
             'user_id': context.user_id,
             'project_id': context.project_id,
             'launch_time': time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()),
-            'instance_type': instance_type,
-            'memory_mb': type_data['memory_mb'],
-            'vcpus': type_data['vcpus'],
-            'local_gb': type_data['local_gb'],
+            'instance_type_id': instance_type['id'],
+            'memory_mb': instance_type['memory_mb'],
+            'vcpus': instance_type['vcpus'],
+            'local_gb': instance_type['local_gb'],
             'display_name': display_name,
             'display_description': display_description,
             'user_data': user_data or '',
@@ -373,11 +380,15 @@
                         instance_id)
             raise
 
-        if (instance['state_description'] == 'terminating'):
+        if instance['state_description'] == 'terminating':
             LOG.warning(_("Instance %s is already being terminated"),
                         instance_id)
             return
 
+        if instance['state_description'] == 'migrating':
+            LOG.warning(_("Instance %s is being migrated"), instance_id)
+            return
+
         self.update(context,
                     instance['id'],
                     state_description='terminating',
@@ -531,8 +542,7 @@
     def resize(self, context, instance_id, flavor_id):
         """Resize a running instance."""
         instance = self.db.instance_get(context, instance_id)
-        current_instance_type = self.db.instance_type_get_by_name(
-            context, instance['instance_type'])
+        current_instance_type = instance['instance_type']
 
         new_instance_type = self.db.instance_type_get_by_flavor_id(
                 context, flavor_id)
@@ -622,6 +632,25 @@
         return {'url': '%s/?token=%s' % (FLAGS.ajax_console_proxy_url,
                 output['token'])}
 
+    def get_vnc_console(self, context, instance_id):
+        """Get a url to a VNC Console."""
+        instance = self.get(context, instance_id)
+        output = self._call_compute_message('get_vnc_console',
+                                            context,
+                                            instance_id)
+        rpc.call(context, '%s' % FLAGS.vncproxy_topic,
+                 {'method': 'authorize_vnc_console',
+                  'args': {'token': output['token'],
+                           'host': output['host'],
+                           'port': output['port']}})
+
+        # hostignore and portignore are compatability params for noVNC
+        return {'url': '%s/vnc_auto.html?token=%s&host=%s&port=%s' % (
+                       FLAGS.vncproxy_url,
+                       output['token'],
+                       'hostignore',
+                       'portignore')}
+
     def get_console_output(self, context, instance_id):
         """Get console output for an an instance"""
         return self._call_compute_message('get_console_output',
 
=== modified file 'nova/compute/instance_types.py'
--- nova/compute/instance_types.py	2011-03-03 01:38:42 +0000
+++ nova/compute/instance_types.py	2011-04-12 11:01:25 +0000
@@ -59,8 +59,8 @@
                     rxtx_quota=rxtx_quota,
                     rxtx_cap=rxtx_cap))
     except exception.DBError, e:
-        LOG.exception(_('DB error: %s' % e))
-        raise exception.ApiError(_("Cannot create instance type: %s" % name))
+        LOG.exception(_('DB error: %s') % e)
+        raise exception.ApiError(_("Cannot create instance type: %s") % name)
 
 
 def destroy(name):
@@ -72,8 +72,8 @@
         try:
             db.instance_type_destroy(context.get_admin_context(), name)
         except exception.NotFound:
-            LOG.exception(_('Instance type %s not found for deletion' % name))
-            raise exception.ApiError(_("Unknown instance type: %s" % name))
+            LOG.exception(_('Instance type %s not found for deletion') % name)
+            raise exception.ApiError(_("Unknown instance type: %s") % name)
 
 
 def purge(name):
@@ -85,8 +85,8 @@
         try:
             db.instance_type_purge(context.get_admin_context(), name)
         except exception.NotFound:
-            LOG.exception(_('Instance type %s not found for purge' % name))
-            raise exception.ApiError(_("Unknown instance type: %s" % name))
+            LOG.exception(_('Instance type %s not found for purge') % name)
+            raise exception.ApiError(_("Unknown instance type: %s") % name)
 
 
 def get_all_types(inactive=0):
@@ -101,41 +101,43 @@
     return get_all_types(context.get_admin_context())
 
 
-def get_instance_type(name):
+def get_default_instance_type():
+    name = FLAGS.default_instance_type
+    try:
+        return get_instance_type_by_name(name)
+    except exception.DBError:
+        raise exception.ApiError(_("Unknown instance type: %s") % name)
+
+
+def get_instance_type(id):
+    """Retrieves single instance type by id"""
+    if id is None:
+        return get_default_instance_type()
+    try:
+        ctxt = context.get_admin_context()
+        return db.instance_type_get_by_id(ctxt, id)
+    except exception.DBError:
+        raise exception.ApiError(_("Unknown instance type: %s") % name)
+
+
+def get_instance_type_by_name(name):
     """Retrieves single instance type by name"""
     if name is None:
-        return FLAGS.default_instance_type
+        return get_default_instance_type()
     try:
         ctxt = context.get_admin_context()
-        inst_type = db.instance_type_get_by_name(ctxt, name)
-        return inst_type
+        return db.instance_type_get_by_name(ctxt, name)
     except exception.DBError:
-        raise exception.ApiError(_("Unknown instance type: %s" % name))
-
-
-def get_by_type(instance_type):
-    """retrieve instance type name"""
-    if instance_type is None:
-        return FLAGS.default_instance_type
-
-    try:
-        ctxt = context.get_admin_context()
-        inst_type = db.instance_type_get_by_name(ctxt, instance_type)
-        return inst_type['name']
-    except exception.DBError, e:
-        LOG.exception(_('DB error: %s' % e))
-        raise exception.ApiError(_("Unknown instance type: %s" %\
-                                    instance_type))
-
-
-def get_by_flavor_id(flavor_id):
-    """retrieve instance type's name by flavor_id"""
+        raise exception.ApiError(_("Unknown instance type: %s") % name)
+
+
+def get_instance_type_by_flavor_id(flavor_id):
+    """retrieve instance type by flavor_id"""
     if flavor_id is None:
-        return FLAGS.default_instance_type
+        return get_default_instance_type()
     try:
         ctxt = context.get_admin_context()
-        flavor = db.instance_type_get_by_flavor_id(ctxt, flavor_id)
-        return flavor['name']
+        return db.instance_type_get_by_flavor_id(ctxt, flavor_id)
     except exception.DBError, e:
-        LOG.exception(_('DB error: %s' % e))
-        raise exception.ApiError(_("Unknown flavor: %s" % flavor_id))
+        LOG.exception(_('DB error: %s') % e)
+        raise exception.ApiError(_("Unknown flavor: %s") % flavor_id)
 
=== modified file 'nova/compute/manager.py'
--- nova/compute/manager.py	2011-04-07 01:08:35 +0000
+++ nova/compute/manager.py	2011-04-12 11:01:25 +0000
@@ -140,12 +140,6 @@
         """
         self.driver.init_host(host=self.host)
 
-    def periodic_tasks(self, context=None):
-        """Tasks to be run at a periodic interval."""
-        super(ComputeManager, self).periodic_tasks(context)
-        if FLAGS.rescue_timeout > 0:
-            self.driver.poll_rescued_instances(FLAGS.rescue_timeout)
-
     def _update_state(self, context, instance_id):
         """Update the state of an instance from the driver info."""
         # FIXME(ja): include other fields from state?
@@ -708,6 +702,15 @@
 
         return self.driver.get_ajax_console(instance_ref)
 
+    @exception.wrap_exception
+    def get_vnc_console(self, context, instance_id):
+        """Return connection information for an vnc console."""
+        context = context.elevated()
+        LOG.debug(_("instance %s: getting vnc console"), instance_id)
+        instance_ref = self.db.instance_get(context, instance_id)
+
+        return self.driver.get_vnc_console(instance_ref)
+
     @checks_instance_lock
     def attach_volume(self, context, instance_id, volume_id, mountpoint):
         """Attach a volume to an instance."""
@@ -1014,11 +1017,20 @@
             error_list = []
 
         try:
+            if FLAGS.rescue_timeout > 0:
+                self.driver.poll_rescued_instances(FLAGS.rescue_timeout)
+        except Exception as ex:
+            LOG.warning(_("Error during poll_rescued_instances: %s"),
+                        unicode(ex))
+            error_list.append(ex)
+
+        try:
             self._poll_instance_states(context)
         except Exception as ex:
             LOG.warning(_("Error during instance poll: %s"),
                         unicode(ex))
             error_list.append(ex)
+
         return error_list
 
     def _poll_instance_states(self, context):
@@ -1032,16 +1044,41 @@
 
         for db_instance in db_instances:
             name = db_instance['name']
+            db_state = db_instance['state']
             vm_instance = vm_instances.get(name)
+
             if vm_instance is None:
-                LOG.info(_("Found instance '%(name)s' in DB but no VM. "
-                           "Setting state to shutoff.") % locals())
-                vm_state = power_state.SHUTOFF
+                # NOTE(justinsb): We have to be very careful here, because a
+                # concurrent operation could be in progress (e.g. a spawn)
+                if db_state == power_state.NOSTATE:
+                    # Assume that NOSTATE => spawning
+                    # TODO(justinsb): This does mean that if we crash during a
+                    # spawn, the machine will never leave the spawning state,
+                    # but this is just the way nova is; this function isn't
+                    # trying to correct that problem.
+                    # We could have a separate task to correct this error.
+                    # TODO(justinsb): What happens during a live migration?
+                    LOG.info(_("Found instance '%(name)s' in DB but no VM. "
+                               "State=%(db_state)s, so assuming spawn is in "
+                               "progress.") % locals())
+                    vm_state = db_state
+                else:
+                    LOG.info(_("Found instance '%(name)s' in DB but no VM. "
+                               "State=%(db_state)s, so setting state to "
+                               "shutoff.") % locals())
+                    vm_state = power_state.SHUTOFF
             else:
                 vm_state = vm_instance.state
                 vms_not_found_in_db.remove(name)
 
-            db_state = db_instance['state']
+            if db_instance['state_description'] == 'migrating':
+                # A situation which db record exists, but no instance"
+                # sometimes occurs while live-migration at src compute,
+                # this case should be ignored.
+                LOG.debug(_("Ignoring %(name)s, as it's currently being "
+                           "migrated.") % locals())
+                continue
+
             if vm_state != db_state:
                 LOG.info(_("DB/VM state mismatch. Changing state from "
                            "'%(db_state)s' to '%(vm_state)s'") % locals())
@@ -1049,12 +1086,8 @@
                                            db_instance['id'],
                                            vm_state)
 
-            if vm_state == power_state.SHUTOFF:
-                # TODO(soren): This is what the compute manager does when you
-                # terminate an instance. At some point I figure we'll have a
-                # "terminated" state and some sort of cleanup job that runs
-                # occasionally, cleaning them out.
-                self.db.instance_destroy(context, db_instance['id'])
+            # NOTE(justinsb): We no longer auto-remove SHUTOFF instances
+            # It's quite hard to get them back when we do.
 
         # Are there VMs not in the DB?
         for vm_not_found_in_db in vms_not_found_in_db:
 
=== modified file 'nova/crypto.py'
--- nova/crypto.py	2011-03-23 04:31:50 +0000
+++ nova/crypto.py	2011-04-12 11:01:25 +0000
@@ -215,9 +215,12 @@
 
 def _ensure_project_folder(project_id):
     if not os.path.exists(ca_path(project_id)):
+        geninter_sh_path = os.path.join(os.path.dirname(__file__),
+                                        'CA',
+                                        'geninter.sh')
         start = os.getcwd()
         os.chdir(ca_folder())
-        utils.execute('sh', 'geninter.sh', project_id,
+        utils.execute('sh', geninter_sh_path, project_id,
                       _project_cert_subject(project_id))
         os.chdir(start)
 
@@ -227,13 +230,16 @@
     csr_fn = os.path.join(project_folder, "server.csr")
     crt_fn = os.path.join(project_folder, "server.crt")
 
+    genvpn_sh_path = os.path.join(os.path.dirname(__file__),
+                                  'CA',
+                                  'genvpn.sh')
     if os.path.exists(crt_fn):
         return
     _ensure_project_folder(project_id)
     start = os.getcwd()
     os.chdir(ca_folder())
     # TODO(vish): the shell scripts could all be done in python
-    utils.execute('sh', 'genvpn.sh',
+    utils.execute('sh', genvpn_sh_path,
                   project_id, _vpn_cert_subject(project_id))
     with open(csr_fn, "r") as csrfile:
         csr_text = csrfile.read()
@@ -263,6 +269,8 @@
     LOG.debug(_("Flags path: %s"), ca_folder)
     start = os.getcwd()
     # Change working dir to CA
+    if not os.path.exists(ca_folder):
+        os.makedirs(ca_folder)
     os.chdir(ca_folder)
     utils.execute('openssl', 'ca', '-batch', '-out', outbound, '-config',
                   './openssl.cnf', '-infiles', inbound)
 
=== modified file 'nova/db/api.py'
--- nova/db/api.py	2011-03-28 08:27:17 +0000
+++ nova/db/api.py	2011-04-12 11:01:25 +0000
@@ -1153,6 +1153,11 @@
     return IMPL.instance_type_get_all(context, inactive)
 
 
+def instance_type_get_by_id(context, id):
+    """Get instance type by id"""
+    return IMPL.instance_type_get_by_id(context, id)
+
+
 def instance_type_get_by_name(context, name):
     """Get instance type by name"""
     return IMPL.instance_type_get_by_name(context, name)
 
=== modified file 'nova/db/sqlalchemy/api.py'
--- nova/db/sqlalchemy/api.py	2011-03-28 08:27:17 +0000
+++ nova/db/sqlalchemy/api.py	2011-04-12 11:01:25 +0000
@@ -660,7 +660,9 @@
                      filter(models.FixedIp.instance_id != None).\
                      filter_by(allocated=0).\
                      update({'instance_id': None,
-                             'leased': 0})
+                             'leased': 0,
+                             'updated_at': datetime.datetime.utcnow()},
+                             synchronize_session='fetch')
     return result
 
 
@@ -829,6 +831,7 @@
                          options(joinedload('volumes')).\
                          options(joinedload_all('fixed_ip.network')).\
                          options(joinedload('metadata')).\
+                         options(joinedload('instance_type')).\
                          filter_by(id=instance_id).\
                          filter_by(deleted=can_read_deleted(context)).\
                          first()
@@ -838,6 +841,7 @@
                          options(joinedload_all('security_groups.rules')).\
                          options(joinedload('volumes')).\
                          options(joinedload('metadata')).\
+                         options(joinedload('instance_type')).\
                          filter_by(project_id=context.project_id).\
                          filter_by(id=instance_id).\
                          filter_by(deleted=False).\
@@ -857,6 +861,7 @@
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
                    options(joinedload_all('fixed_ip.network')).\
+                   options(joinedload('instance_type')).\
                    filter_by(deleted=can_read_deleted(context)).\
                    all()
 
@@ -868,6 +873,7 @@
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
                    options(joinedload_all('fixed_ip.network')).\
+                   options(joinedload('instance_type')).\
                    filter_by(deleted=can_read_deleted(context)).\
                    filter_by(user_id=user_id).\
                    all()
@@ -880,6 +886,7 @@
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
                    options(joinedload_all('fixed_ip.network')).\
+                   options(joinedload('instance_type')).\
                    filter_by(host=host).\
                    filter_by(deleted=can_read_deleted(context)).\
                    all()
@@ -894,6 +901,7 @@
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
                    options(joinedload_all('fixed_ip.network')).\
+                   options(joinedload('instance_type')).\
                    filter_by(project_id=project_id).\
                    filter_by(deleted=can_read_deleted(context)).\
                    all()
@@ -908,6 +916,7 @@
                        options(joinedload_all('fixed_ip.floating_ips')).\
                        options(joinedload('security_groups')).\
                        options(joinedload_all('fixed_ip.network')).\
+                       options(joinedload('instance_type')).\
                        filter_by(reservation_id=reservation_id).\
                        filter_by(deleted=can_read_deleted(context)).\
                        all()
@@ -916,6 +925,7 @@
                        options(joinedload_all('fixed_ip.floating_ips')).\
                        options(joinedload('security_groups')).\
                        options(joinedload_all('fixed_ip.network')).\
+                       options(joinedload('instance_type')).\
                        filter_by(project_id=context.project_id).\
                        filter_by(reservation_id=reservation_id).\
                        filter_by(deleted=False).\
@@ -928,6 +938,7 @@
     return session.query(models.Instance).\
                    options(joinedload_all('fixed_ip.floating_ips')).\
                    options(joinedload('security_groups')).\
+                   options(joinedload('instance_type')).\
                    filter_by(project_id=project_id).\
                    filter_by(image_id=FLAGS.vpn_image_id).\
                    filter_by(deleted=can_read_deleted(context)).\
@@ -2428,6 +2439,19 @@
 
 
 @require_context
+def instance_type_get_by_id(context, id):
+    """Returns a dict describing specific instance_type"""
+    session = get_session()
+    inst_type = session.query(models.InstanceTypes).\
+                    filter_by(id=id).\
+                    first()
+    if not inst_type:
+        raise exception.NotFound(_("No instance type with id %s") % id)
+    else:
+        return dict(inst_type)
+
+
+@require_context
 def instance_type_get_by_name(context, name):
     """Returns a dict describing specific instance_type"""
     session = get_session()
 
=== added file 'nova/db/sqlalchemy/migrate_repo/versions/014_add_instance_type_id_to_instances.py'
--- nova/db/sqlalchemy/migrate_repo/versions/014_add_instance_type_id_to_instances.py	1970-01-01 00:00:00 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/014_add_instance_type_id_to_instances.py	2011-04-12 11:01:25 +0000
@@ -0,0 +1,84 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2010 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 *
+from sqlalchemy.sql import text
+from migrate import *
+
+#from nova import log as logging
+
+
+meta = MetaData()
+
+
+c_instance_type = Column('instance_type',
+                           String(length=255, convert_unicode=False,
+                                  assert_unicode=None, unicode_error=None,
+                                  _warn_on_bytestring=False),
+                           nullable=True)
+
+c_instance_type_id = Column('instance_type_id',
+                           String(length=255, convert_unicode=False,
+                                  assert_unicode=None, unicode_error=None,
+                                  _warn_on_bytestring=False),
+                           nullable=True)
+
+instance_types = Table('instance_types', meta,
+        Column('id', Integer(),  primary_key=True, nullable=False),
+        Column('name',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False),
+                      unique=True))
+
+
+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 = Table('instances', meta, autoload=True,
+                      autoload_with=migrate_engine)
+
+    instances.create_column(c_instance_type_id)
+
+    recs = migrate_engine.execute(instance_types.select())
+    for row in recs:
+        type_id = row[0]
+        type_name = row[1]
+        migrate_engine.execute(instances.update()\
+            .where(instances.c.instance_type == type_name)\
+            .values(instance_type_id=type_id))
+
+    instances.c.instance_type.drop()
+
+
+def downgrade(migrate_engine):
+    meta.bind = migrate_engine
+
+    instances = Table('instances', meta, autoload=True,
+                      autoload_with=migrate_engine)
+
+    instances.create_column(c_instance_type)
+
+    recs = migrate_engine.execute(instance_types.select())
+    for row in recs:
+        type_id = row[0]
+        type_name = row[1]
+        migrate_engine.execute(instances.update()\
+            .where(instances.c.instance_type_id == type_id)\
+            .values(instance_type=type_name))
+
+    instances.c.instance_type_id.drop()
 
=== removed file 'nova/db/sqlalchemy/migrate_repo/versions/014_diablo.py'
--- nova/db/sqlalchemy/migrate_repo/versions/014_diablo.py	2011-03-28 08:27:17 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/014_diablo.py	1970-01-01 00:00:00 +0000
@@ -1,92 +0,0 @@
-# vim: tabstop=4 shiftwidth=4 softtabstop=4
-
-# Copyright (c) 2011 NTT.
-# All Rights Reserved.
-#
-#    Licensed under the Apache License, Version 2.0 (the "License"); you may
-#    not use this file except in compliance with the License. You may obtain
-#    a copy of the License at
-#
-#         http://www.apache.org/licenses/LICENSE-2.0
-#
-#    Unless required by applicable law or agreed to in writing, software
-#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
-#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
-#    License for the specific language governing permissions and limitations
-#    under the License.
-
-from sqlalchemy import *
-from migrate import *
-
-from nova import log as logging
-
-meta = MetaData()
-
-# Just for the ForeignKey and column creation to succeed, these are not the
-# actual definitions of instances or services.
-instances = Table('instances', meta,
-        Column('id', Integer(), primary_key=True, nullable=False),
-        )
-
-#
-# New Tables
-#
-instance_virtual_nic_association = Table(
-        'instance_virtual_nic_association', meta,        
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(), primary_key=True, nullable=False),
-        Column('virtual_nic_id', 
-               String(length=255, convert_unicode=False, assert_unicode=None, 
-                      unicode_error=None, _warn_on_bytestring=False), 
-               nullable=False),
-        Column('instance_id', Integer(), ForeignKey('instances.id'),
-               nullable=False),
-        )
-
-project_network_service_association = Table(
-        'project_network_service_association', meta,
-        Column('created_at', DateTime(timezone=False)),
-        Column('updated_at', DateTime(timezone=False)),
-        Column('deleted_at', DateTime(timezone=False)),
-        Column('deleted', Boolean(create_constraint=True, name=None)),
-        Column('id', Integer(), primary_key=True, nullable=False),
-        Column('project_id',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False),
-               nullable=False),
-        Column('network_service',
-               String(length=255, convert_unicode=False, assert_unicode=None,
-                      unicode_error=None, _warn_on_bytestring=False),
-               nullable=False),
-        UniqueConstraint('project_id')
-        )
-
-def upgrade(migrate_engine):
-    # Upgrade operations go here. Don't create your own engine;
-    # bind migrate_engine to your metadata
-    meta.bind = migrate_engine
-
-    for table in (instance_virtual_nic_association, 
-                  project_network_service_association):
-        try:
-            table.create()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while creating table')
-            raise
-
-def downgrade(migrate_engine):
-    # Operations to reverse the above upgrade go here.
-    meta.bind = migrate_engine
-
-    for table in (project_network_service_association, 
-                  instance_virtual_nic_association):
-        try:
-            table.drop()
-        except Exception:
-            logging.info(repr(table))
-            logging.exception('Exception while dropping table')
-            raise
 
=== added file 'nova/db/sqlalchemy/migrate_repo/versions/015_diablo.py'
--- nova/db/sqlalchemy/migrate_repo/versions/015_diablo.py	1970-01-01 00:00:00 +0000
+++ nova/db/sqlalchemy/migrate_repo/versions/015_diablo.py	2011-04-12 11:01:25 +0000
@@ -0,0 +1,93 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 NTT.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+from sqlalchemy import *
+from migrate import *
+
+from nova import log as logging
+
+meta = MetaData()
+
+# Just for the ForeignKey and column creation to succeed, these are not the
+# actual definitions of instances or services.
+instances = Table('instances', meta,
+        Column('id', Integer(), primary_key=True, nullable=False),
+        )
+
+#
+# New Tables
+#
+instance_virtual_nic_association = Table(
+        'instance_virtual_nic_association', meta,        
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(), primary_key=True, nullable=False),
+        Column('virtual_nic_id', 
+               String(length=255, convert_unicode=False, assert_unicode=None, 
+                      unicode_error=None, _warn_on_bytestring=False), 
+               nullable=False),
+        Column('instance_id', Integer(), ForeignKey('instances.id'),
+               nullable=False),
+        )
+
+project_network_service_association = Table(
+        'project_network_service_association', meta,
+        Column('created_at', DateTime(timezone=False)),
+        Column('updated_at', DateTime(timezone=False)),
+        Column('deleted_at', DateTime(timezone=False)),
+        Column('deleted', Boolean(create_constraint=True, name=None)),
+        Column('id', Integer(), primary_key=True, nullable=False),
+        Column('project_id',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False),
+               nullable=False),
+        Column('network_service',
+               String(length=255, convert_unicode=False, assert_unicode=None,
+                      unicode_error=None, _warn_on_bytestring=False),
+               nullable=False),
+        UniqueConstraint('project_id')
+        )
+
+def upgrade(migrate_engine):
+    # Upgrade operations go here. Don't create your own engine;
+    # bind migrate_engine to your metadata
+    meta.bind = migrate_engine
+    return
+
+    for table in (instance_virtual_nic_association, 
+                  project_network_service_association):
+        try:
+            table.create()
+        except Exception:
+            logging.info(repr(table))
+            logging.exception('Exception while creating table')
+            raise
+
+def downgrade(migrate_engine):
+    # Operations to reverse the above upgrade go here.
+    meta.bind = migrate_engine
+
+    for table in (project_network_service_association, 
+                  instance_virtual_nic_association):
+        try:
+            table.drop()
+        except Exception:
+            logging.info(repr(table))
+            logging.exception('Exception while dropping table')
+            raise
 
=== modified file 'nova/db/sqlalchemy/models.py'
--- nova/db/sqlalchemy/models.py	2011-03-28 08:27:17 +0000
+++ nova/db/sqlalchemy/models.py	2011-04-12 11:01:25 +0000
@@ -209,7 +209,7 @@
     hostname = Column(String(255))
     host = Column(String(255))  # , ForeignKey('hosts.id'))
 
-    instance_type = Column(String(255))
+    instance_type_id = Column(String(255))
 
     user_data = Column(Text)
 
@@ -268,6 +268,12 @@
     rxtx_quota = Column(Integer, nullable=False, default=0)
     rxtx_cap = Column(Integer, nullable=False, default=0)
 
+    instances = relationship(Instance,
+                           backref=backref('instance_type', uselist=False),
+                           foreign_keys=id,
+                           primaryjoin='and_(Instance.instance_type_id == '
+                                       'InstanceTypes.id)')
+
 
 class Volume(BASE, NovaBase):
     """Represents a block storage device that can be attached to a vm."""
 
=== added file 'nova/image/fake.py'
--- nova/image/fake.py	1970-01-01 00:00:00 +0000
+++ nova/image/fake.py	2011-04-12 11:01:25 +0000
@@ -0,0 +1,113 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright 2011 Justin Santa Barbara
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+"""Implementation of an fake image service"""
+
+import copy
+import datetime
+
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova.image import service
+
+
+LOG = logging.getLogger('nova.image.fake')
+
+
+FLAGS = flags.FLAGS
+
+
+class FakeImageService(service.BaseImageService):
+    """Mock (fake) image service for unit testing."""
+
+    def __init__(self):
+        self.images = {}
+        # NOTE(justinsb): The OpenStack API can't upload an image?
+        # So, make sure we've got one..
+        timestamp = datetime.datetime(2011, 01, 01, 01, 02, 03)
+        image = {'id': '123456',
+                 'name': 'fakeimage123456',
+                 'created_at': timestamp,
+                 'updated_at': timestamp,
+                 'status': 'active',
+                 'container_format': 'ami',
+                 'disk_format': 'raw',
+                 'properties': {'kernel_id': FLAGS.null_kernel,
+                                'ramdisk_id': FLAGS.null_kernel}
+                }
+        self.create(None, image)
+        super(FakeImageService, self).__init__()
+
+    def index(self, context):
+        """Returns list of images."""
+        return copy.deepcopy(self.images.values())
+
+    def detail(self, context):
+        """Return list of detailed image information."""
+        return copy.deepcopy(self.images.values())
+
+    def show(self, context, image_id):
+        """Get data about specified image.
+
+        Returns a dict containing image data for the given opaque image id.
+
+        """
+        image_id = int(image_id)
+        image = self.images.get(image_id)
+        if image:
+            return copy.deepcopy(image)
+        LOG.warn("Unable to find image id %s.  Have images: %s",
+                 image_id, self.images)
+        raise exception.NotFound
+
+    def create(self, context, data):
+        """Store the image data and return the new image id.
+
+        :raises Duplicate if the image already exist.
+
+        """
+        image_id = int(data['id'])
+        if self.images.get(image_id):
+            raise exception.Duplicate()
+
+        self.images[image_id] = copy.deepcopy(data)
+
+    def update(self, context, image_id, data):
+        """Replace the contents of the given image with the new data.
+
+        :raises NotFound if the image does not exist.
+
+        """
+        image_id = int(image_id)
+        if not self.images.get(image_id):
+            raise exception.NotFound
+        self.images[image_id] = copy.deepcopy(data)
+
+    def delete(self, context, image_id):
+        """Delete the given image.
+
+        :raises NotFound if the image does not exist.
+
+        """
+        image_id = int(image_id)
+        removed = self.images.pop(image_id, None)
+        if not removed:
+            raise exception.NotFound
+
+    def delete_all(self):
+        """Clears out all images."""
+        self.images.clear()
 
=== modified file 'nova/image/glance.py'
--- nova/image/glance.py	2011-03-24 21:50:27 +0000
+++ nova/image/glance.py	2011-04-12 11:01:25 +0000
@@ -151,6 +151,8 @@
 
         :raises NotFound if the image does not exist.
         """
+        # NOTE(vish): show is to check if image is available
+        self.show(context, image_id)
         try:
             image_meta = self.client.update_image(image_id, image_meta, data)
         except glance_exception.NotFound:
@@ -165,6 +167,8 @@
 
         :raises NotFound if the image does not exist.
         """
+        # NOTE(vish): show is to check if image is available
+        self.show(context, image_id)
         try:
             result = self.client.delete_image(image_id)
         except glance_exception.NotFound:
@@ -186,33 +190,6 @@
         image_meta = _convert_timestamps_to_datetimes(image_meta)
         return image_meta
 
-    @staticmethod
-    def _is_image_available(context, image_meta):
-        """
-        Images are always available if they are public or if the user is an
-        admin.
-
-        Otherwise, we filter by project_id (if present) and then fall-back to
-        images owned by user.
-        """
-        # FIXME(sirp): We should be filtering by user_id on the Glance side
-        # for security; however, we can't do that until we get authn/authz
-        # sorted out. Until then, filtering in Nova.
-        if image_meta['is_public'] or context.is_admin:
-            return True
-
-        properties = image_meta['properties']
-
-        if context.project_id and ('project_id' in properties):
-            return str(properties['project_id']) == str(project_id)
-
-        try:
-            user_id = properties['user_id']
-        except KeyError:
-            return False
-
-        return str(user_id) == str(context.user_id)
-
 
 # utility functions
 def _convert_timestamps_to_datetimes(image_meta):
@@ -220,7 +197,7 @@
     Returns image with known timestamp fields converted to datetime objects
     """
     for attr in ['created_at', 'updated_at', 'deleted_at']:
-        if image_meta.get(attr) is not None:
+        if image_meta.get(attr):
             image_meta[attr] = _parse_glance_iso8601_timestamp(
                 image_meta[attr])
     return image_meta
@@ -230,8 +207,13 @@
     """
     Parse a subset of iso8601 timestamps into datetime objects
     """
-    GLANCE_FMT = "%Y-%m-%dT%H:%M:%S"
-    ISO_FMT = "%Y-%m-%dT%H:%M:%S.%f"
-    # FIXME(sirp): Glance is not returning in ISO format, we should fix Glance
-    # to do so, and then switch to parsing it here
-    return datetime.datetime.strptime(timestamp, GLANCE_FMT)
+    iso_formats = ["%Y-%m-%dT%H:%M:%S.%f", "%Y-%m-%dT%H:%M:%S"]
+
+    for iso_format in iso_formats:
+        try:
+            return datetime.datetime.strptime(timestamp, iso_format)
+        except ValueError:
+            pass
+
+    raise ValueError(_("%(timestamp)s does not follow any of the "
+                       "signatures: %(ISO_FORMATS)s") % locals())
 
=== modified file 'nova/image/local.py'
--- nova/image/local.py	2011-03-23 05:50:53 +0000
+++ nova/image/local.py	2011-04-12 11:01:25 +0000
@@ -84,7 +84,10 @@
     def show(self, context, image_id):
         try:
             with open(self._path_to(image_id)) as metadata_file:
-                return json.load(metadata_file)
+                image_meta = json.load(metadata_file)
+                if not self._is_image_available(context, image_meta):
+                    raise exception.NotFound
+                return image_meta
         except (IOError, ValueError):
             raise exception.NotFound
 
@@ -119,10 +122,15 @@
         image_path = self._path_to(image_id, None)
         if not os.path.exists(image_path):
             os.mkdir(image_path)
-        return self.update(context, image_id, metadata, data)
+        return self._store(context, image_id, metadata, data)
 
     def update(self, context, image_id, metadata, data=None):
         """Replace the contents of the given image with the new data."""
+        # NOTE(vish): show is to check if image is available
+        self.show(context, image_id)
+        return self._store(context, image_id, metadata, data)
+
+    def _store(self, context, image_id, metadata, data=None):
         metadata['id'] = image_id
         try:
             if data:
@@ -140,9 +148,11 @@
 
     def delete(self, context, image_id):
         """Delete the given image.
-        Raises OSError if the image does not exist.
+        Raises NotFound if the image does not exist.
 
         """
+        # NOTE(vish): show is to check if image is available
+        self.show(context, image_id)
         try:
             shutil.rmtree(self._path_to(image_id, None))
         except (IOError, ValueError):
 
=== modified file 'nova/image/s3.py'
--- nova/image/s3.py	2011-03-14 17:59:41 +0000
+++ nova/image/s3.py	2011-04-12 11:01:25 +0000
@@ -31,6 +31,7 @@
 
 import boto.s3.connection
 
+from nova import crypto
 from nova import exception
 from nova import flags
 from nova import utils
@@ -45,6 +46,7 @@
 
 
 class S3ImageService(service.BaseImageService):
+    """Wraps an existing image service to support s3 based register"""
     def __init__(self, service=None, *args, **kwargs):
         if service == None:
             service = utils.import_object(FLAGS.image_service)
@@ -57,52 +59,23 @@
         return image
 
     def delete(self, context, image_id):
-        # FIXME(vish): call to show is to check filter
-        self.show(context, image_id)
         self.service.delete(context, image_id)
 
     def update(self, context, image_id, metadata, data=None):
-        # FIXME(vish): call to show is to check filter
-        self.show(context, image_id)
         image = self.service.update(context, image_id, metadata, data)
         return image
 
     def index(self, context):
-        images = self.service.index(context)
-        # FIXME(vish): index doesn't filter so we do it manually
-        return self._filter(context, images)
+        return self.service.index(context)
 
     def detail(self, context):
-        images = self.service.detail(context)
-        # FIXME(vish): detail doesn't filter so we do it manually
-        return self._filter(context, images)
-
-    @classmethod
-    def _is_visible(cls, context, image):
-        return (context.is_admin
-                or context.project_id == image['properties']['owner_id']
-                or image['properties']['is_public'] == 'True')
-
-    @classmethod
-    def _filter(cls, context, images):
-        filtered = []
-        for image in images:
-            if not cls._is_visible(context, image):
-                continue
-            filtered.append(image)
-        return filtered
+        return self.service.detail(context)
 
     def show(self, context, image_id):
-        image = self.service.show(context, image_id)
-        if not self._is_visible(context, image):
-            raise exception.NotFound
-        return image
+        return self.service.show(context, image_id)
 
     def show_by_name(self, context, name):
-        image = self.service.show_by_name(context, name)
-        if not self._is_visible(context, image):
-            raise exception.NotFound
-        return image
+        return self.service.show(context, name)
 
     @staticmethod
     def _conn(context):
@@ -166,7 +139,7 @@
             arch = 'x86_64'
 
         properties = metadata['properties']
-        properties['owner_id'] = context.project_id
+        properties['project_id'] = context.project_id
         properties['architecture'] = arch
 
         if kernel_id:
@@ -175,8 +148,6 @@
         if ramdisk_id:
             properties['ramdisk_id'] = ec2utils.ec2_id_to_id(ramdisk_id)
 
-        properties['is_public'] = False
-        properties['type'] = image_type
         metadata.update({'disk_format': image_format,
                          'container_format': image_format,
                          'status': 'queued',
@@ -210,7 +181,7 @@
 
             # FIXME(vish): grab key from common service so this can run on
             #              any host.
-            cloud_pk = os.path.join(FLAGS.ca_path, "private/cakey.pem")
+            cloud_pk = crypto.key_path(context.project_id)
 
             decrypted_filename = os.path.join(image_path, 'image.tar.gz')
             self._decrypt_image(encrypted_filename, encrypted_key,
 
=== modified file 'nova/image/service.py'
--- nova/image/service.py	2011-03-24 21:13:55 +0000
+++ nova/image/service.py	2011-04-12 11:01:25 +0000
@@ -136,6 +136,33 @@
         """
         raise NotImplementedError
 
+    @staticmethod
+    def _is_image_available(context, image_meta):
+        """
+        Images are always available if they are public or if the user is an
+        admin.
+
+        Otherwise, we filter by project_id (if present) and then fall-back to
+        images owned by user.
+        """
+        # FIXME(sirp): We should be filtering by user_id on the Glance side
+        # for security; however, we can't do that until we get authn/authz
+        # sorted out. Until then, filtering in Nova.
+        if image_meta['is_public'] or context.is_admin:
+            return True
+
+        properties = image_meta['properties']
+
+        if context.project_id and ('project_id' in properties):
+            return str(properties['project_id']) == str(context.project_id)
+
+        try:
+            user_id = properties['user_id']
+        except KeyError:
+            return False
+
+        return str(user_id) == str(context.user_id)
+
     @classmethod
     def _translate_to_base(cls, metadata):
         """Return a metadata dictionary that is BaseImageService compliant.
 
=== modified file 'nova/network/api.py'
--- nova/network/api.py	2011-02-22 23:50:42 +0000
+++ nova/network/api.py	2011-04-12 11:01:25 +0000
@@ -66,6 +66,21 @@
         if isinstance(fixed_ip, str) or isinstance(fixed_ip, unicode):
             fixed_ip = self.db.fixed_ip_get_by_address(context, fixed_ip)
         floating_ip = self.db.floating_ip_get_by_address(context, floating_ip)
+        # Check if the floating ip address is allocated
+        if floating_ip['project_id'] is None:
+            raise exception.ApiError(_("Address (%s) is not allocated") %
+                                       floating_ip['address'])
+        # Check if the floating ip address is allocated to the same project
+        if floating_ip['project_id'] != context.project_id:
+            LOG.warn(_("Address (%(address)s) is not allocated to your "
+                       "project (%(project)s)"),
+                       {'address': floating_ip['address'],
+                       'project': context.project_id})
+            raise exception.ApiError(_("Address (%(address)s) is not "
+                                       "allocated to your project"
+                                       "(%(project)s)") %
+                                        {'address': floating_ip['address'],
+                                        'project': context.project_id})
         # NOTE(vish): Perhaps we should just pass this on to compute and
         #             let compute communicate with network.
         host = fixed_ip['network']['host']
 
=== modified file 'nova/network/linux_net.py'
--- nova/network/linux_net.py	2011-04-03 19:04:27 +0000
+++ nova/network/linux_net.py	2011-04-12 11:01:25 +0000
@@ -391,6 +391,12 @@
              'dev', FLAGS.public_interface)
 
 
+def ensure_metadata_ip():
+    """Sets up local metadata ip"""
+    _execute('sudo', 'ip', 'addr', 'add', '169.254.169.254/32',
+             'scope', 'link', 'dev', 'lo', check_exit_code=False)
+
+
 def ensure_vlan_forward(public_ip, port, private_ip):
     """Sets up forwarding rules for vlan"""
     iptables_manager.ipv4['filter'].add_rule("FORWARD",
@@ -442,6 +448,7 @@
     return interface
 
 
[e-mail]('ensure_bridge', external=True)
 def ensure_bridge(bridge, interface, net_attrs=None):
     """Create a bridge unless it already exists.
 
@@ -495,6 +502,8 @@
             fields = line.split()
             if fields and fields[0] == "0.0.0.0" and fields[-1] == interface:
                 gateway = fields[1]
+                _execute('sudo', 'route', 'del', 'default', 'gw', gateway,
+                         'dev', interface, check_exit_code=False)
         out, err = _execute('sudo', 'ip', 'addr', 'show', 'dev', interface,
                             'scope', 'global')
         for line in out.split("\n"):
@@ -504,7 +513,7 @@
                 _execute(*_ip_bridge_cmd('del', params, fields[-1]))
                 _execute(*_ip_bridge_cmd('add', params, bridge))
         if gateway:
-            _execute('sudo', 'route', 'add', '0.0.0.0', 'gw', gateway)
+            _execute('sudo', 'route', 'add', 'default', 'gw', gateway)
         out, err = _execute('sudo', 'brctl', 'addif', bridge, interface,
                             check_exit_code=False)
 
 
=== modified file 'nova/network/manager.py'
--- nova/network/manager.py	2011-04-03 19:04:27 +0000
+++ nova/network/manager.py	2011-04-12 11:01:25 +0000
@@ -126,6 +126,7 @@
         standalone service.
         """
         self.driver.init_host()
+        self.driver.ensure_metadata_ip()
         # Set up networking for the projects for which we're already
         # the designated network host.
         ctxt = context.get_admin_context()
 
=== added file 'nova/network/xenapi_net.py'
--- nova/network/xenapi_net.py	1970-01-01 00:00:00 +0000
+++ nova/network/xenapi_net.py	2011-04-12 11:01:25 +0000
@@ -0,0 +1,85 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# Copyright (c) 2011 Citrix Systems, Inc.
+# 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.
+
+"""
+Implements vlans, bridges, and iptables rules using linux utilities.
+"""
+
+import os
+
+from nova import db
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import utils
+from nova.virt.xenapi_conn import XenAPISession
+from nova.virt.xenapi import network_utils
+
+LOG = logging.getLogger("nova.xenapi_net")
+
+FLAGS = flags.FLAGS
+
+
+def ensure_vlan_bridge(vlan_num, bridge, net_attrs=None):
+    """Create a vlan and bridge unless they already exist."""
+    # Open xenapi session
+    LOG.debug("ENTERING ensure_vlan_bridge in xenapi net")
+    url = FLAGS.xenapi_connection_url
+    username = FLAGS.xenapi_connection_username
+    password = FLAGS.xenapi_connection_password
+    session = XenAPISession(url, username, password)
+    # Check whether bridge already exists
+    # Retrieve network whose name_label is "bridge"
+    network_ref = network_utils.NetworkHelper.find_network_with_name_label(
+                                                                       session,
+                                                                       bridge)
+    if network_ref == None:
+        # If bridge does not exists
+        # 1 - create network
+        description = "network for nova bridge %s" % bridge
+        network_rec = {'name_label': bridge,
+                       'name_description': description,
+                       'other_config': {}}
+        network_ref = session.call_xenapi('network.create', network_rec)
+        # 2 - find PIF for VLAN
+        expr = 'field "device" = "%s" and \
+                field "VLAN" = "-1"' % FLAGS.vlan_interface
+        pifs = session.call_xenapi('PIF.get_all_records_where', expr)
+        pif_ref = None
+        # Multiple PIF are ok: we are dealing with a pool
+        if len(pifs) == 0: