Merge lp:~citrix-openstack/nova/xenapi-netinject-prop into lp:~citrix-openstack/nova/xenapi

[Salvatore Orlando]

~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
NOVA-CORE DEVELOPERS SHOULD NOT REVIEW THIS MERGE PROPOSAL
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

This is for Citrix OpenStack team only. We propose for merge into a cache of lp:nova to generate diffs for our internal peer review.

Proposing a new approach for _get_vm_opaqueref:

1) assume instance_or_vm parameter is an instance object, try to fetch name attribute
2) if AttributeError or KeyError is raised, check if instance_or_vm is integer.
2.a) if yes, it could be an instance id. Fetch instance from database; use instance name for looking up VM.
2.b) if no, it could be an instance name. Use it for looking up VM.
3) lookup VM on XenServer backend
4) check result of lookup operation
4.a) if lookup succeeds (vm!=None) return VM ref.
4.b) if lookup fails, instance_or_vm might already be a VM ref. To this aim, try to fetch VM record using instance_or_vm as vm_ref. If the operation succeeds return instance_or_vm as VM ref.
5) if none of the above has succeeded, raise Exception.

[lp:~citrix-openstack/nova/xenapi-netinject-prop]

697. By Salvatore Orlando on 2011-03-08

merge trunk

now using refactored _get_vm_opaqueref

698. By Salvatore Orlando on 2011-03-08

using get_uuid in place of get_record in _get_vm_opaqueref
changed SessionBase._getter in fake xenapi in order to return HANDLE_INVALID failure when reference is not in DB
(was NotImplementedException)

[Armando Migliaccio (armando-migliaccio)]

does this branch depends on another branch? I see a lot of new stuff that does not seem related to network injection

review: Needs Information

[Salvatore Orlando (salvatore-orlando)]

> does this branch depends on another branch? I see a lot of new stuff that does
> not seem related to network injection

nova/xenapi is not synchronized with trunk. I'll do that now.

[lp:~citrix-openstack/nova/xenapi-netinject-prop]

699. By Salvatore Orlando on 2011-03-10

Merge trunk
Conflicts solved

700. By Salvatore Orlando on 2011-03-13

Merged with trunk

Fixed testing instrastructure:
 - stubbed out LoopingCall.start
 - unstubbed db.instance_create
 - now using fake context in spawn tests
 - moved fake xenstore ops into fake driver to avoid code duplication

Fixed pep8 errors

701. By Salvatore Orlando on 2011-03-13

merge trunk

702. By Salvatore Orlando on 2011-03-13

Removed excess LOG.debug line

703. By Salvatore Orlando on 2011-03-14

merge trunk

704. By Salvatore Orlando on 2011-03-14

merge trunk

705. By Salvatore Orlando on 2011-03-16

Merge trunk

706. By Salvatore Orlando on 2011-03-17

merge trunk

707. By Salvatore Orlando on 2011-03-17

merge trunk

708. By Salvatore Orlando on 2011-03-18

merge trunk

709. By Salvatore Orlando on 2011-03-18

Fixed issue arisen from recent feature update (utils.execute)

710. By Salvatore Orlando on 2011-03-21

merge trunk

711. By Salvatore Orlando on 2011-03-22

merge trunk

712. By Salvatore Orlando on 2011-03-23

merged with trunk
Updated xenapi network injection for IPv6
Updated unit tests

713. By Salvatore Orlando on 2011-03-24

Addressing Rick Clark's comments.

714. By Salvatore Orlando on 2011-03-24

merge trunk

715. By Salvatore Orlando on 2011-03-24

merge trunk

716. By Salvatore Orlando on 2011-03-24

Sorted out a problem occurred with units tests for VM migration

717. By Salvatore Orlando on 2011-03-24

merge trunk

718. By Salvatore Orlando on 2011-03-24

Stubbing out utils.execute for migrate tests

719. By Salvatore Orlando on 2011-03-24

Addressing Trey's comments.
Removed disk_get_injectables, using _get_network_info's return value.

720. By Salvatore Orlando on 2011-03-25

Merged with trunk
Updated net injection for xenapi reflecting recent changes for libvirt

721. By Salvatore Orlando on 2011-03-25

merge trunk

722. By Salvatore Orlando on 2011-03-25

minor pep8 fix in db/fakes.py

723. By Salvatore Orlando on 2011-03-25

merge trunk

=== modified file '.mailmap'
--- .mailmap	2011-03-03 05:10:42 +0000
+++ .mailmap	2011-03-25 13:43:55 +0000
@@ -28,7 +28,12 @@
 <[e-mail]> <[e-mail]>
 <[e-mail]> <mdietz@openstack>
 <[e-mail]> <mordred@hudson>
-<[e-mail]> <[e-mail]>
+<<<<<<< TREE
+<[e-mail]> <[e-mail]>
+=======
+<[e-mail]> <[e-mail]>
+<[e-mail]> <[e-mail]>
+>>>>>>> MERGE-SOURCE
 <[e-mail]> <[e-mail]>
 <[e-mail]> <[e-mail]> 
 <[e-mail]> <laner@controller>
 
=== modified file 'Authors'
--- Authors	2011-03-03 05:10:42 +0000
+++ Authors	2011-03-25 13:43:55 +0000
@@ -1,4 +1,5 @@
 Andy Smith <[e-mail]>
+Andy Southgate <[e-mail]>
 Anne Gentle <[e-mail]>
 Anthony Young <[e-mail]>
 Antony Messerli <[e-mail]>
@@ -19,7 +20,9 @@
 Ed Leafe <[e-mail]>
 Eldar Nugaev <[e-mail]>
 Eric Day <[e-mail]>
+Eric Windisch <[e-mail]>
 Ewan Mellor <[e-mail]>
+Gabe Westmaas <[e-mail]>
 Hisaharu Ishii <[e-mail]>
 Hisaki Ohara <[e-mail]>
 Ilya Alekseyev <[e-mail]>
@@ -31,7 +34,12 @@
 Jonathan Bryce <[e-mail]>
 Jordan Rinke <[e-mail]>
 Josh Durgin <[e-mail]>
-Josh Kearney <[e-mail]>
+<<<<<<< TREE
+Josh Kearney <[e-mail]>
+=======
+Josh Kearney <[e-mail]>
+Josh Kleinpeter <[e-mail]>
+>>>>>>> MERGE-SOURCE
 Joshua McKenty <[e-mail]>
 Justin Santa Barbara <[e-mail]>
 Kei Masumoto <[e-mail]>
@@ -39,7 +47,12 @@
 Kevin L. Mitchell <[e-mail]>
 Koji Iida <[e-mail]>
 Lorin Hochstein <[e-mail]>
-Masanori Itoh <[e-mail]>
+<<<<<<< TREE
+Masanori Itoh <[e-mail]>
+=======
+Mark Washenberger <[e-mail]>
+Masanori Itoh <[e-mail]>
+>>>>>>> MERGE-SOURCE
 Matt Dietz <[e-mail]>
 Michael Gundlach <[e-mail]>
 Monsyne Dragon <[e-mail]>
@@ -58,6 +71,7 @@
 Ryan Lucio <[e-mail]>
 Salvatore Orlando <[e-mail]>
 Sandy Walsh <[e-mail]>
+Sateesh Chodapuneedi <[e-mail]>
 Soren Hansen <[e-mail]>
 Thierry Carrez <[e-mail]>
 Todd Willey <[e-mail]>
 
=== modified file 'MANIFEST.in'
--- MANIFEST.in	2011-02-24 14:19:29 +0000
+++ MANIFEST.in	2011-03-25 13:43:55 +0000
@@ -25,6 +25,7 @@
 include nova/db/sqlalchemy/migrate_repo/README
 include nova/virt/interfaces.template
 include nova/virt/libvirt*.xml.template
+include nova/virt/cpuinfo.xml.template
 include nova/tests/CA/
 include nova/tests/CA/cacert.pem
 include nova/tests/CA/private/
 
=== modified file 'bin/nova-ajax-console-proxy'
--- bin/nova-ajax-console-proxy	2011-02-25 21:15:51 +0000
+++ bin/nova-ajax-console-proxy	2011-03-25 13:43:55 +0000
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2010 United States Government as represented by the
 
=== modified file 'bin/nova-api'
--- bin/nova-api	2011-03-09 00:45:20 +0000
+++ bin/nova-api	2011-03-25 13:43:55 +0000
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2010 United States Government as represented by the
 
=== modified file 'bin/nova-dhcpbridge'
--- bin/nova-dhcpbridge	2011-02-23 19:20:52 +0000
+++ bin/nova-dhcpbridge	2011-03-25 13:43:55 +0000
@@ -94,7 +94,7 @@
     """Get the list of hosts for an interface."""
     ctxt = context.get_admin_context()
     network_ref = db.network_get_by_bridge(ctxt, interface)
-    return linux_net.get_dhcp_hosts(ctxt, network_ref['id'])
+    return linux_net.get_dhcp_leases(ctxt, network_ref['id'])
 
 
 def main():
 
=== modified file 'bin/nova-direct-api'
--- bin/nova-direct-api	2011-02-23 23:26:52 +0000
+++ bin/nova-direct-api	2011-03-25 13:43:55 +0000
@@ -1,5 +1,5 @@
 #!/usr/bin/env python
-# pylint: disable-msg=C0103
+# pylint: disable=C0103
 # vim: tabstop=4 shiftwidth=4 softtabstop=4
 
 # Copyright 2010 United States Government as represented by the
@@ -34,29 +34,71 @@
 
 gettext.install('nova', unicode=1)
 
+from nova import compute
 from nova import flags
-from nova import log as logging
+<<<<<<< TREE
+from nova import log as logging
+=======
+from nova import log as logging
+from nova import network
+>>>>>>> MERGE-SOURCE
 from nova import utils
+from nova import volume
 from nova import wsgi
 from nova.api import direct
-from nova.compute import api as compute_api
 
 
 FLAGS = flags.FLAGS
 flags.DEFINE_integer('direct_port', 8001, 'Direct API port')
 flags.DEFINE_string('direct_host', '0.0.0.0', 'Direct API host')
-flags.DEFINE_flag(flags.HelpFlag())
-flags.DEFINE_flag(flags.HelpshortFlag())
-flags.DEFINE_flag(flags.HelpXMLFlag())
-
+<<<<<<< TREE
+flags.DEFINE_flag(flags.HelpFlag())
+flags.DEFINE_flag(flags.HelpshortFlag())
+flags.DEFINE_flag(flags.HelpXMLFlag())
+
+=======
+flags.DEFINE_flag(flags.HelpFlag())
+flags.DEFINE_flag(flags.HelpshortFlag())
+flags.DEFINE_flag(flags.HelpXMLFlag())
+
+
+# An example of an API that only exposes read-only methods.
+# In this case we're just limiting which methods are exposed.
+class ReadOnlyCompute(direct.Limited):
+    """Read-only Compute API."""
+
+    _allowed = ['get', 'get_all', 'get_console_output']
+
+
+# An example of an API that provides a backwards compatibility layer.
+# In this case we're overwriting the implementation to ensure
+# compatibility with an older version. In reality we would want the
+# "description=None" to be part of the actual API so that code
+# like this isn't even necessary, but this example shows what one can
+# do if that isn't the situation.
+class VolumeVersionOne(direct.Limited):
+    _allowed = ['create', 'delete', 'update', 'get']
+
+    def create(self, context, size, name):
+        self.proxy.create(context, size, name, description=None)
+
+>>>>>>> MERGE-SOURCE
 
 if __name__ == '__main__':
     utils.default_flagfile()
     FLAGS(sys.argv)
     logging.setup()
 
-    direct.register_service('compute', compute_api.API())
+    direct.register_service('compute', compute.API())
+    direct.register_service('volume', volume.API())
+    direct.register_service('network', network.API())
     direct.register_service('reflect', direct.Reflection())
+
+    # Here is how we could expose the code in the examples above.
+    #direct.register_service('compute-readonly',
+    #                        ReadOnlyCompute(compute.API()))
+    #direct.register_service('volume-v1', VolumeVersionOne(volume.API()))
+
     router = direct.Router()
     with_json = direct.JsonParamsMiddleware(router)
     with_req = direct.PostParamsMiddleware(with_json)
 
=== modified file 'bin/nova-instancemonitor'
--- bin/nova-instancemonitor	2011-02-21 21:46:41 +0000
+++ bin/nova-instancemonitor	2011-03-25 13:43:55 +0000
@@ -50,7 +50,7 @@
 
 if __name__ == '__builtin__':
     LOG.warn(_('Starting instance monitor'))
-    # pylint: disable-msg=C0103
+    # pylint: disable=C0103
     monitor = monitor.InstanceMonitor()
 
     # This is the parent service that twistd will be looking for when it
 
=== modified file 'bin/nova-manage'
--- bin/nova-manage	2011-03-13 09:49:56 +0000
+++ bin/nova-manage	2011-03-25 13:43:55 +0000
@@ -96,10 +96,18 @@
 flags.DECLARE('vlan_start', 'nova.network.manager')
 flags.DECLARE('vpn_start', 'nova.network.manager')
 flags.DECLARE('fixed_range_v6', 'nova.network.manager')
-flags.DECLARE('images_path', 'nova.image.local')
-flags.DEFINE_flag(flags.HelpFlag())
-flags.DEFINE_flag(flags.HelpshortFlag())
-flags.DEFINE_flag(flags.HelpXMLFlag())
+<<<<<<< TREE
+flags.DECLARE('images_path', 'nova.image.local')
+flags.DEFINE_flag(flags.HelpFlag())
+flags.DEFINE_flag(flags.HelpshortFlag())
+flags.DEFINE_flag(flags.HelpXMLFlag())
+=======
+flags.DECLARE('images_path', 'nova.image.local')
+flags.DECLARE('libvirt_type', 'nova.virt.libvirt_conn')
+flags.DEFINE_flag(flags.HelpFlag())
+flags.DEFINE_flag(flags.HelpshortFlag())
+flags.DEFINE_flag(flags.HelpXMLFlag())
+>>>>>>> MERGE-SOURCE
 
 
 def param2id(object_id):
@@ -437,6 +445,7 @@
                     "been created.\nPlease create a database by running a "
                     "nova-api server on this host.")
 
+<<<<<<< TREE
 AccountCommands = ProjectCommands
 
 
@@ -470,6 +479,46 @@
                                   fixed_ip['address'],
                                   mac_address, hostname, host)
 
+=======
+AccountCommands = ProjectCommands
+
+
+class FixedIpCommands(object):
+    """Class for managing fixed ip."""
+
+    def list(self, host=None):
+        """Lists all fixed ips (optionally by host) arguments: [host]"""
+        ctxt = context.get_admin_context()
+
+        try:
+            if host == None:
+                fixed_ips = db.fixed_ip_get_all(ctxt)
+            else:
+                fixed_ips = db.fixed_ip_get_all_by_host(ctxt, host)
+        except exception.NotFound as ex:
+            print "error: %s" % ex
+            sys.exit(2)
+
+        print "%-18s\t%-15s\t%-17s\t%-15s\t%s" % (_('network'),
+                                                  _('IP address'),
+                                                  _('MAC address'),
+                                                  _('hostname'),
+                                                  _('host'))
+        for fixed_ip in fixed_ips:
+            hostname = None
+            host = None
+            mac_address = None
+            if fixed_ip['instance']:
+                instance = fixed_ip['instance']
+                hostname = instance['hostname']
+                host = instance['host']
+                mac_address = instance['mac_address']
+            print "%-18s\t%-15s\t%-17s\t%-15s\t%s" % (
+                    fixed_ip['network']['cidr'],
+                    fixed_ip['address'],
+                    mac_address, hostname, host)
+
+>>>>>>> MERGE-SOURCE
 
 class FloatingIpCommands(object):
     """Class for managing floating ip."""
@@ -513,11 +562,12 @@
                network_size=None, vlan_start=None,
                vpn_start=None, fixed_range_v6=None, label='public'):
         """Creates fixed ips for host by range
-        arguments: [fixed_range=FLAG], [num_networks=FLAG],
+        arguments: fixed_range=FLAG, [num_networks=FLAG],
                    [network_size=FLAG], [vlan_start=FLAG],
                    [vpn_start=FLAG], [fixed_range_v6=FLAG]"""
         if not fixed_range:
-            fixed_range = FLAGS.fixed_range
+            raise TypeError(_('Fixed range in the form of 10.0.0.0/8 is '
+                              'required to create networks.'))
         if not num_networks:
             num_networks = FLAGS.num_networks
         if not network_size:
@@ -536,28 +586,89 @@
                                     vlan_start=int(vlan_start),
                                     vpn_start=int(vpn_start),
                                     cidr_v6=fixed_range_v6,
-                                    label=label)
-
-    def list(self):
-        """List all created networks"""
-        print "%-18s\t%-15s\t%-15s\t%-15s" % (_('network'),
-                                              _('netmask'),
-                                              _('start address'),
-                                              'DNS')
-        for network in db.network_get_all(context.get_admin_context()):
-            print "%-18s\t%-15s\t%-15s\t%-15s" % (network.cidr,
-                                network.netmask,
-                                network.dhcp_start,
-                                network.dns)
-
-    def delete(self, fixed_range):
-        """Deletes a network"""
-        network = db.network_get_by_cidr(context.get_admin_context(), \
-                                         fixed_range)
-        if network.project_id is not None:
-            raise ValueError(_('Network must be disassociated from project %s'
-                               ' before delete' % network.project_id))
-        db.network_delete_safe(context.get_admin_context(), network.id)
+<<<<<<< TREE
+                                    label=label)
+
+    def list(self):
+        """List all created networks"""
+        print "%-18s\t%-15s\t%-15s\t%-15s" % (_('network'),
+                                              _('netmask'),
+                                              _('start address'),
+                                              'DNS')
+        for network in db.network_get_all(context.get_admin_context()):
+            print "%-18s\t%-15s\t%-15s\t%-15s" % (network.cidr,
+                                network.netmask,
+                                network.dhcp_start,
+                                network.dns)
+
+    def delete(self, fixed_range):
+        """Deletes a network"""
+        network = db.network_get_by_cidr(context.get_admin_context(), \
+                                         fixed_range)
+        if network.project_id is not None:
+            raise ValueError(_('Network must be disassociated from project %s'
+                               ' before delete' % network.project_id))
+        db.network_delete_safe(context.get_admin_context(), network.id)
+=======
+                                    label=label)
+
+    def list(self):
+        """List all created networks"""
+        print "%-18s\t%-15s\t%-15s\t%-15s" % (_('network'),
+                                              _('netmask'),
+                                              _('start address'),
+                                              'DNS')
+        for network in db.network_get_all(context.get_admin_context()):
+            print "%-18s\t%-15s\t%-15s\t%-15s" % (network.cidr,
+                                network.netmask,
+                                network.dhcp_start,
+                                network.dns)
+
+    def delete(self, fixed_range):
+        """Deletes a network"""
+        network = db.network_get_by_cidr(context.get_admin_context(), \
+                                         fixed_range)
+        if network.project_id is not None:
+            raise ValueError(_('Network must be disassociated from project %s'
+                               ' before delete' % network.project_id))
+        db.network_delete_safe(context.get_admin_context(), network.id)
+
+
+class VmCommands(object):
+    """Class for mangaging VM instances."""
+
+    def live_migration(self, ec2_id, dest):
+        """Migrates a running instance to a new machine.
+
+        :param ec2_id: instance id which comes from euca-describe-instance.
+        :param dest: destination host name.
+
+        """
+
+        ctxt = context.get_admin_context()
+        instance_id = ec2utils.ec2_id_to_id(ec2_id)
+
+        if (FLAGS.connection_type != 'libvirt' or
+           (FLAGS.connection_type == 'libvirt' and
+            FLAGS.libvirt_type not in ['kvm', 'qemu'])):
+            msg = _('Only KVM and QEmu are supported for now. Sorry!')
+            raise exception.Error(msg)
+
+        if (FLAGS.volume_driver != 'nova.volume.driver.AOEDriver' and \
+            FLAGS.volume_driver != 'nova.volume.driver.ISCSIDriver'):
+            msg = _("Support only AOEDriver and ISCSIDriver. Sorry!")
+            raise exception.Error(msg)
+
+        rpc.call(ctxt,
+                 FLAGS.scheduler_topic,
+                 {"method": "live_migration",
+                  "args": {"instance_id": instance_id,
+                           "dest": dest,
+                           "topic": FLAGS.compute_topic}})
+
+        print _('Migration of %s initiated.'
+               'Check its progress using euca-describe-instances.') % ec2_id
+>>>>>>> MERGE-SOURCE
 
 
 class ServiceCommands(object):
@@ -604,6 +715,59 @@
             return
         db.service_update(ctxt, svc['id'], {'disabled': True})
 
+    def describe_resource(self, host):
+        """Describes cpu/memory/hdd info for host.
+
+        :param host: hostname.
+
+        """
+
+        result = rpc.call(context.get_admin_context(),
+                     FLAGS.scheduler_topic,
+                     {"method": "show_host_resources",
+                      "args": {"host": host}})
+
+        if type(result) != dict:
+            print _('An unexpected error has occurred.')
+            print _('[Result]'), result
+        else:
+            cpu = result['resource']['vcpus']
+            mem = result['resource']['memory_mb']
+            hdd = result['resource']['local_gb']
+            cpu_u = result['resource']['vcpus_used']
+            mem_u = result['resource']['memory_mb_used']
+            hdd_u = result['resource']['local_gb_used']
+
+            print 'HOST\t\t\tPROJECT\t\tcpu\tmem(mb)\tdisk(gb)'
+            print '%s(total)\t\t\t%s\t%s\t%s' % (host, cpu, mem, hdd)
+            print '%s(used)\t\t\t%s\t%s\t%s' % (host, cpu_u, mem_u, hdd_u)
+            for p_id, val in result['usage'].items():
+                print '%s\t\t%s\t\t%s\t%s\t%s' % (host,
+                                                  p_id,
+                                                  val['vcpus'],
+                                                  val['memory_mb'],
+                                                  val['local_gb'])
+
+    def update_resource(self, host):
+        """Updates available vcpu/memory/disk info for host.
+
+        :param host: hostname.
+
+        """
+
+        ctxt = context.get_admin_context()
+        service_refs = db.service_get_all_by_host(ctxt, host)
+        if len(service_refs) <= 0:
+            raise exception.Invalid(_('%s does not exist.') % host)
+
+        service_refs = [s for s in service_refs if s['topic'] == 'compute']
+        if len(service_refs) <= 0:
+            raise exception.Invalid(_('%s is not compute node.') % host)
+
+        rpc.call(ctxt,
+                 db.queue_get_for(ctxt, FLAGS.compute_topic, host),
+                 {"method": "update_available_resource"})
+
 
 class LogCommands(object):
     def request(self, request_id, logfile='/var/log/nova.log'):
@@ -629,6 +793,49 @@
         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"""
 
@@ -676,6 +883,7 @@
                            "mountpoint": volume['mountpoint']}})
 
 
+<<<<<<< TREE
 class InstanceTypeCommands(object):
     """Class for managing instance types / flavors."""
 
@@ -898,6 +1106,230 @@
         self._convert_images(machine_images)
 
 
+=======
+class InstanceTypeCommands(object):
+    """Class for managing instance types / flavors."""
+
+    def _print_instance_types(self, n, val):
+        deleted = ('', ', inactive')[val["deleted"] == 1]
+        print ("%s: Memory: %sMB, VCPUS: %s, Storage: %sGB, FlavorID: %s, "
+            "Swap: %sGB, RXTX Quota: %sGB, RXTX Cap: %sMB%s") % (
+            n, val["memory_mb"], val["vcpus"], val["local_gb"],
+            val["flavorid"], val["swap"], val["rxtx_quota"],
+            val["rxtx_cap"], deleted)
+
+    def create(self, name, memory, vcpus, local_gb, flavorid,
+               swap=0, rxtx_quota=0, rxtx_cap=0):
+        """Creates instance types / flavors
+           arguments: name memory vcpus local_gb flavorid [swap] [rxtx_quota]
+                      [rxtx_cap]
+        """
+        try:
+            instance_types.create(name, memory, vcpus, local_gb,
+                                  flavorid, swap, rxtx_quota, rxtx_cap)
+        except exception.InvalidInputException:
+            print "Must supply valid parameters to create instance type"
+            print e
+            sys.exit(1)
+        except exception.DBError, e:
+            print "DB Error: %s" % e
+            sys.exit(2)
+        except:
+            print "Unknown error"
+            sys.exit(3)
+        else:
+            print "%s created" % name
+
+    def delete(self, name, purge=None):
+        """Marks instance types / flavors as deleted
+        arguments: name"""
+        try:
+            if purge == "--purge":
+                instance_types.purge(name)
+                verb = "purged"
+            else:
+                instance_types.destroy(name)
+                verb = "deleted"
+        except exception.ApiError:
+            print "Valid instance type name is required"
+            sys.exit(1)
+        except exception.DBError, e:
+            print "DB Error: %s" % e
+            sys.exit(2)
+        except:
+            sys.exit(3)
+        else:
+            print "%s %s" % (name, verb)
+
+    def list(self, name=None):
+        """Lists all active or specific instance types / flavors
+        arguments: [name]"""
+        try:
+            if name == None:
+                inst_types = instance_types.get_all_types()
+            elif name == "--all":
+                inst_types = instance_types.get_all_types(True)
+            else:
+                inst_types = instance_types.get_instance_type(name)
+        except exception.DBError, e:
+            _db_error(e)
+        if isinstance(inst_types.values()[0], dict):
+            for k, v in inst_types.iteritems():
+                self._print_instance_types(k, v)
+        else:
+            self._print_instance_types(name, inst_types)
+
+
+class ImageCommands(object):
+    """Methods for dealing with a cloud in an odd state"""
+
+    def __init__(self, *args, **kwargs):
+        self.image_service = utils.import_object(FLAGS.image_service)
+
+    def _register(self, image_type, disk_format, container_format,
+                  path, owner, name=None, is_public='T',
+                  architecture='x86_64', kernel_id=None, ramdisk_id=None):
+        meta = {'is_public': True,
+                'name': name,
+                'disk_format': disk_format,
+                'container_format': container_format,
+                'properties': {'image_state': 'available',
+                               'owner': owner,
+                               'type': image_type,
+                               'architecture': architecture,
+                               'image_location': 'local',
+                               'is_public': (is_public == 'T')}}
+        print image_type, meta
+        if kernel_id:
+            meta['properties']['kernel_id'] = int(kernel_id)
+        if ramdisk_id:
+            meta['properties']['ramdisk_id'] = int(ramdisk_id)
+        elevated = context.get_admin_context()
+        try:
+            with open(path) as ifile:
+                image = self.image_service.create(elevated, meta, ifile)
+            new = image['id']
+            print _("Image registered to %(new)s (%(new)08x).") % locals()
+            return new
+        except Exception as exc:
+            print _("Failed to register %(path)s: %(exc)s") % locals()
+
+    def all_register(self, image, kernel, ramdisk, owner, name=None,
+                 is_public='T', architecture='x86_64'):
+        """Uploads an image, kernel, and ramdisk into the image_service
+        arguments: image kernel ramdisk owner [name] [is_public='T']
+                   [architecture='x86_64']"""
+        kernel_id = self.kernel_register(kernel, owner, None,
+                                   is_public, architecture)
+        ramdisk_id = self.ramdisk_register(ramdisk, owner, None,
+                                    is_public, architecture)
+        self.image_register(image, owner, name, is_public,
+                       architecture, 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'):
+        """Uploads an image into the image_service
+        arguments: path owner [name] [is_public='T'] [architecture='x86_64']
+                   [kernel_id=None] [ramdisk_id=None]
+                   [disk_format='ami'] [container_format='ami']"""
+        return self._register('machine', disk_format, container_format, path,
+                              owner, name, is_public, architecture,
+                              kernel_id, ramdisk_id)
+
+    def kernel_register(self, path, owner, name=None, is_public='T',
+               architecture='x86_64'):
+        """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,
+                              is_public, architecture)
+
+    def ramdisk_register(self, path, owner, name=None, is_public='T',
+                architecture='x86_64'):
+        """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,
+                              is_public, architecture)
+
+    def _lookup(self, old_image_id):
+        try:
+            internal_id = ec2utils.ec2_id_to_id(old_image_id)
+            image = self.image_service.show(context, internal_id)
+        except exception.NotFound:
+            image = self.image_service.show_by_name(context, old_image_id)
+        return image['id']
+
+    def _old_to_new(self, old):
+        mapping = {'machine': 'ami',
+                   'kernel': 'aki',
+                   'ramdisk': 'ari'}
+        container_format = mapping[old['type']]
+        disk_format = container_format
+        new = {'disk_format': disk_format,
+               'container_format': container_format,
+               'is_public': True,
+               'name': old['imageId'],
+               'properties': {'image_state': old['imageState'],
+                              'owner': old['imageOwnerId'],
+                              'architecture': old['architecture'],
+                              'type': old['type'],
+                              'image_location': old['imageLocation'],
+                              'is_public': old['isPublic']}}
+        if old.get('kernelId'):
+            new['properties']['kernel_id'] = self._lookup(old['kernelId'])
+        if old.get('ramdiskId'):
+            new['properties']['ramdisk_id'] = self._lookup(old['ramdiskId'])
+        return new
+
+    def _convert_images(self, images):
+        elevated = context.get_admin_context()
+        for image_path, image_metadata in images.iteritems():
+            meta = self._old_to_new(image_metadata)
+            old = meta['name']
+            try:
+                with open(image_path) as ifile:
+                    image = self.image_service.create(elevated, meta, ifile)
+                new = image['id']
+                print _("Image %(old)s converted to " \
+                        "%(new)s (%(new)08x).") % locals()
+            except Exception as exc:
+                print _("Failed to convert %(old)s: %(exc)s") % locals()
+
+    def convert(self, directory):
+        """Uploads old objectstore images in directory to new service
+        arguments: directory"""
+        machine_images = {}
+        other_images = {}
+        directory = os.path.abspath(directory)
+        # NOTE(vish): If we're importing from the images path dir, attempt
+        #             to move the files out of the way before importing
+        #             so we aren't writing to the same directory. This
+        #             may fail if the dir was a mointpoint.
+        if (FLAGS.image_service == 'nova.image.local.LocalImageService'
+            and directory == os.path.abspath(FLAGS.images_path)):
+            new_dir = "%s_bak" % directory
+            os.move(directory, new_dir)
+            os.mkdir(directory)
+            directory = new_dir
+        for fn in glob.glob("%s/*/info.json" % directory):
+            try:
+                image_path = os.path.join(fn.rpartition('/')[0], 'image')
+                with open(fn) as metadata_file:
+                    image_metadata = json.load(metadata_file)
+                if image_metadata['type'] == 'machine':
+                    machine_images[image_path] = image_metadata
+                else:
+                    other_images[image_path] = image_metadata
+            except Exception as exc:
+                print _("Failed to load %(fn)s.") % locals()
+        # NOTE(vish): do kernels and ramdisks first so images
+        self._convert_images(other_images)
+        self._convert_images(machine_images)
+
+
+>>>>>>> MERGE-SOURCE
 CATEGORIES = [
     ('user', UserCommands),
     ('account', AccountCommands),
@@ -908,13 +1340,22 @@
     ('fixed', FixedIpCommands),
     ('floating', FloatingIpCommands),
     ('network', NetworkCommands),
+    ('vm', VmCommands),
     ('service', ServiceCommands),
     ('log', LogCommands),
     ('db', DbCommands),
+<<<<<<< TREE
     ('volume', VolumeCommands),
     ('instance_type', InstanceTypeCommands),
     ('image', ImageCommands),
     ('flavor', InstanceTypeCommands)]
+=======
+    ('volume', VolumeCommands),
+    ('instance_type', InstanceTypeCommands),
+    ('image', ImageCommands),
+    ('flavor', InstanceTypeCommands),
+    ('instance', InstanceCommands)]
+>>>>>>> MERGE-SOURCE
 
 
 def lazy_match(name, key_value_tuples):
 
=== modified file 'bin/nova-objectstore'
--- bin/nova-objectstore	2010-12-14 23:22:03 +0000
+++ bin/nova-objectstore	2011-03-25 13:43:55 +0000
@@ -36,9 +36,10 @@
 gettext.install('nova', unicode=1)
 
 from nova import flags
+from nova import log as logging
 from nova import utils
-from nova import twistd
-from nova.objectstore import handler
+from nova import wsgi
+from nova.objectstore import s3server
 
 
 FLAGS = flags.FLAGS
@@ -46,7 +47,9 @@
 
 if __name__ == '__main__':
     utils.default_flagfile()
-    twistd.serve(__file__)
-
-if __name__ == '__builtin__':
-    application = handler.get_application()  # pylint: disable-msg=C0103
+    FLAGS(sys.argv)
+    logging.setup()
+    router = s3server.S3Application(FLAGS.buckets_path)
+    server = wsgi.Server()
+    server.start(router, FLAGS.s3_port, host=FLAGS.s3_host)
+    server.wait()
 
=== modified file 'bin/stack'
--- bin/stack	2011-01-18 15:24:20 +0000
+++ bin/stack	2011-03-25 13:43:55 +0000
@@ -59,11 +59,21 @@
 
 def format_help(d):
     """Format help text, keys are labels and values are descriptions."""
+    MAX_INDENT = 30
     indent = max([len(k) for k in d])
+    if indent > MAX_INDENT:
+        indent = MAX_INDENT - 6
+
     out = []
     for k, v in d.iteritems():
-        t = textwrap.TextWrapper(initial_indent='   %s   ' % k.ljust(indent),
-                                 subsequent_indent=' ' * (indent + 6))
+        if (len(k) + 6) > MAX_INDENT:
+            out.extend(['   %s' % k])
+            initial_indent = ' ' * (indent + 6)
+        else:
+            initial_indent = '   %s   ' % k.ljust(indent)
+        subsequent_indent = ' ' * (indent + 6)
+        t = textwrap.TextWrapper(initial_indent=initial_indent,
+                                 subsequent_indent=subsequent_indent)
         out.extend(t.wrap(v))
     return out
 
 
=== modified file 'contrib/boto_v6/ec2/connection.py'
--- contrib/boto_v6/ec2/connection.py	2011-01-12 03:05:27 +0000
+++ contrib/boto_v6/ec2/connection.py	2011-03-25 13:43:55 +0000
@@ -4,8 +4,10 @@
 @author: Nachi Ueno <[e-mail]>
 '''
 import boto
+import base64
 import boto.ec2
 from boto_v6.ec2.instance import  ReservationV6
+from boto.ec2.securitygroup import SecurityGroup
 
 
 class EC2ConnectionV6(boto.ec2.EC2Connection):
@@ -39,3 +41,101 @@
             self.build_filter_params(params, filters)
         return self.get_list('DescribeInstancesV6', params,
                              [('item', ReservationV6)])
+
+    def run_instances(self, image_id, min_count=1, max_count=1,
+                      key_name=None, security_groups=None,
+                      user_data=None, addressing_type=None,
+                      instance_type='m1.small', placement=None,
+                      kernel_id=None, ramdisk_id=None,
+                      monitoring_enabled=False, subnet_id=None,
+                      block_device_map=None):
+        """
+        Runs an image on EC2.
+
+        :type image_id: string
+        :param image_id: The ID of the image to run
+
+        :type min_count: int
+        :param min_count: The minimum number of instances to launch
+
+        :type max_count: int
+        :param max_count: The maximum number of instances to launch
+
+        :type key_name: string
+        :param key_name: The name of the key pair with which to
+                         launch instances
+
+        :type security_groups: list of strings
+        :param security_groups: The names of the security groups with
+                                which to associate instances
+
+        :type user_data: string
+        :param user_data: The user data passed to the launched instances
+
+        :type instance_type: string
+        :param instance_type: The type of instance to run
+                              (m1.small, m1.large, m1.xlarge)
+
+        :type placement: string
+        :param placement: The availability zone in which to launch
+                          the instances
+
+        :type kernel_id: string
+        :param kernel_id: The ID of the kernel with which to
+                          launch the instances
+
+        :type ramdisk_id: string
+        :param ramdisk_id: The ID of the RAM disk with which to
+                           launch the instances
+
+        :type monitoring_enabled: bool
+        :param monitoring_enabled: Enable CloudWatch monitoring
+                                   on the instance.
+
+        :type subnet_id: string
+        :param subnet_id: The subnet ID within which to launch
+                          the instances for VPC.
+
+        :type block_device_map:
+            :class:`boto.ec2.blockdevicemapping.BlockDeviceMapping`
+        :param block_device_map: A BlockDeviceMapping data structure
+                                 describing the EBS volumes associated
+                                 with the Image.
+
+        :rtype: Reservation
+        :return: The :class:`boto.ec2.instance.ReservationV6`
+                 associated with the request for machines
+        """
+        params = {'ImageId': image_id,
+                  'MinCount': min_count,
+                  'MaxCount': max_count}
+        if key_name:
+            params['KeyName'] = key_name
+        if security_groups:
+            l = []
+            for group in security_groups:
+                if isinstance(group, SecurityGroup):
+                    l.append(group.name)
+                else:
+                    l.append(group)
+            self.build_list_params(params, l, 'SecurityGroup')
+        if user_data:
+            params['UserData'] = base64.b64encode(user_data)
+        if addressing_type:
+            params['AddressingType'] = addressing_type
+        if instance_type:
+            params['InstanceType'] = instance_type
+        if placement:
+            params['Placement.AvailabilityZone'] = placement
+        if kernel_id:
+            params['KernelId'] = kernel_id
+        if ramdisk_id:
+            params['RamdiskId'] = ramdisk_id
+        if monitoring_enabled:
+            params['Monitoring.Enabled'] = 'true'
+        if subnet_id:
+            params['SubnetId'] = subnet_id
+        if block_device_map:
+            block_device_map.build_list_params(params)
+        return self.get_object('RunInstances', params,
+                               ReservationV6, verb='POST')
 
=== modified file 'contrib/nova.sh'
--- contrib/nova.sh	2011-03-08 00:01:43 +0000
+++ contrib/nova.sh	2011-03-25 13:43:55 +0000
@@ -76,6 +76,7 @@
     sudo apt-get install -y python-migrate python-eventlet python-gflags python-ipy python-tempita
     sudo apt-get install -y python-libvirt python-libxml2 python-routes python-cheetah
     sudo apt-get install -y python-netaddr python-paste python-pastedeploy python-glance
+    sudo apt-get install -y python-multiprocessing
 
     if [ "$USE_IPV6" == 1 ]; then
         sudo apt-get install -y radvd
 
=== modified file 'doc/source/_static/tweaks.css'
--- doc/source/_static/tweaks.css	2010-11-11 22:32:24 +0000
+++ doc/source/_static/tweaks.css	2011-03-25 13:43:55 +0000
@@ -69,3 +69,150 @@
 .tweet_list li .tweet_avatar {
     float: left;
 }
+
+/* ------------------------------------------
+PURE CSS SPEECH BUBBLES
+by Nicolas Gallagher
+- http://nicolasgallagher.com/pure-css-speech-bubbles/
+
+http://nicolasgallagher.com
+http://twitter.com/necolas
+
+Created: 02 March 2010
+Version: 1.1 (21 October 2010)
+
+Dual licensed under MIT and GNU GPLv2 © Nicolas Gallagher 
+------------------------------------------ */
+/* THE SPEECH BUBBLE
+------------------------------------------------------------------------------------------------------------------------------- */
+
+/* THE SPEECH BUBBLE
+------------------------------------------------------------------------------------------------------------------------------- */
+
+.triangle-border {
+	position:relative;
+	padding:15px;
+	margin:1em 0 3em;
+	border:5px solid #BC1518;
+	color:#333;
+	background:#fff;
+	
+	/* css3 */
+	-moz-border-radius:10px;
+	-webkit-border-radius:10px;
+	border-radius:10px;
+}
+
+/* Variant : for left positioned triangle
+------------------------------------------ */
+
+.triangle-border.left {
+	margin-left:30px;
+}
+
+/* Variant : for right positioned triangle
+------------------------------------------ */
+
+.triangle-border.right {
+	margin-right:30px;
+}
+
+/* THE TRIANGLE
+------------------------------------------------------------------------------------------------------------------------------- */
+
+.triangle-border:before {
+	content:"";
+	display:block; /* reduce the damage in FF3.0 */
+	position:absolute;
+	bottom:-40px; /* value = - border-top-width - border-bottom-width */
+	left:40px; /* controls horizontal position */
+	width:0;
+	height:0;
+	border:20px solid transparent;
+	border-top-color:#BC1518;
+}
+
+/* creates the smaller  triangle */
+.triangle-border:after {
+	content:"";
+	display:block; /* reduce the damage in FF3.0 */
+	position:absolute;
+	bottom:-26px; /* value = - border-top-width - border-bottom-width */
+	left:47px; /* value = (:before left) + (:before border-left) - (:after border-left) */
+	width:0;
+	height:0;
+	border:13px solid transparent;
+	border-top-color:#fff;
+}
+
+/* Variant : top
+------------------------------------------ */
+
+/* creates the larger triangle */
+.triangle-border.top:before {
+	top:-40px; /* value = - border-top-width - border-bottom-width */
+	right:40px; /* controls horizontal position */
+	bottom:auto;
+	left:auto;
+	border:20px solid transparent;
+	border-bottom-color:#BC1518;
+}
+
+/* creates the smaller  triangle */
+.triangle-border.top:after {
+	top:-26px; /* value = - border-top-width - border-bottom-width */
+	right:47px; /* value = (:before right) + (:before border-right) - (:after border-right) */
+	bottom:auto;
+	left:auto;
+	border:13px solid transparent;
+	border-bottom-color:#fff;
+}
+
+/* Variant : left
+------------------------------------------ */
+
+/* creates the larger triangle */
+.triangle-border.left:before {
+	top:10px; /* controls vertical position */
+	left:-30px; /* value = - border-left-width - border-right-width */
+	bottom:auto;
+	border-width:15px 30px 15px 0;
+	border-style:solid;
+	border-color:transparent #BC1518;
+}
+
+/* creates the smaller  triangle */
+.triangle-border.left:after {
+	top:16px; /* value = (:before top) + (:before border-top) - (:after border-top) */
+	left:-21px; /* value = - border-left-width - border-right-width */
+	bottom:auto;
+	border-width:9px 21px 9px 0;
+	border-style:solid;
+	border-color:transparent #fff;
+}
+
+/* Variant : right
+------------------------------------------ */
+
+/* creates the larger triangle */
+.triangle-border.right:before {
+	top:10px; /* controls vertical position */
+	right:-30px; /* value = - border-left-width - border-right-width */
+	bottom:auto;
+    left:auto;
+	border-width:15px 0 15px 30px;
+	border-style:solid;
+	border-color:transparent #BC1518;
+}
+
+/* creates the smaller  triangle */
+.triangle-border.right:after {
+	top:16px; /* value = (:before top) + (:before border-top) - (:after border-top) */
+	right:-21px; /* value = - border-left-width - border-right-width */
+	bottom:auto;
+    left:auto;
+	border-width:9px 0 9px 21px;
+	border-style:solid;
+	border-color:transparent #fff;
+}
+
 
=== modified file 'doc/source/_theme/layout.html'
--- doc/source/_theme/layout.html	2010-11-05 22:52:59 +0000
+++ doc/source/_theme/layout.html	2011-03-25 13:43:55 +0000
@@ -71,12 +71,21 @@
               </p>
           </div>
           <script type="text/javascript">$('#searchbox').show(0);</script>
+          
+          <p class="triangle-border right">
+				Psst... hey. You're reading the latest content, but it might be out of sync with code. You can read <a href="http://nova.openstack.org/2011.1">Nova 2011.1 docs</a> or <a href="http://docs.openstack.org">all OpenStack docs</a> too.
+			</p>
+          
           {%- endif %}
 
           {%- if pagename == "index" %}
-                <h3>{{ _('Twitter Feed') }}</h3>
+          
+          
+          <h3>{{ _('Twitter Feed') }}</h3>
                 <div id="twitter_feed" class='twitter_feed'></div>
           {%- endif %}
+          
+          
 
 
           {%- endblock %}
 
=== added file 'doc/source/images/vmwareapi_blockdiagram.jpg'
 Binary files doc/source/images/vmwareapi_blockdiagram.jpg	1970-01-01 00:00:00 +0000 and doc/source/images/vmwareapi_blockdiagram.jpg	2011-03-25 13:43:55 +0000 differ
=== added file 'doc/source/vmwareapi_readme.rst'
--- doc/source/vmwareapi_readme.rst	1970-01-01 00:00:00 +0000
+++ doc/source/vmwareapi_readme.rst	2011-03-25 13:43:55 +0000
@@ -0,0 +1,218 @@
+..
+      Copyright (c) 2010 Citrix Systems, Inc.
+      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.
+
+VMware ESX/ESXi Server Support for OpenStack Compute
+====================================================
+
+Introduction
+------------
+A module named 'vmwareapi' is added to 'nova.virt' to add support of VMware ESX/ESXi hypervisor to OpenStack compute (Nova). Nova may now use VMware vSphere as a compute provider. 
+
+The basic requirement is to support VMware vSphere 4.1 as a compute provider within Nova. As the deployment architecture, support both ESX and ESXi. VM storage is restricted to VMFS volumes on local drives. vCenter is not required by the current design, and is not currently supported. Instead, Nova Compute talks directly to ESX/ESXi.
+
+The 'vmwareapi' module is integrated with Glance, so that VM images can be streamed from there for boot on ESXi using Glance server for image storage & retrieval.
+
+Currently supports Nova's flat networking model (Flat Manager) & VLAN networking model.
+
+.. image:: images/vmwareapi_blockdiagram.jpg
+
+
+System Requirements
+-------------------
+Following software components are required for building the cloud using OpenStack on top of ESX/ESXi Server(s): 
+
+* OpenStack
+* Glance Image service
+* VMware ESX v4.1 or VMware ESXi(licensed) v4.1
+
+VMware ESX Requirements
+-----------------------
+* ESX credentials with administration/root privileges
+* Single local hard disk at the ESX host
+* An ESX Virtual Machine Port Group (For Flat Networking)
+* An ESX physical network adapter (For VLAN networking)
+* Need to enable "vSphere Web Access" in  "vSphere client" UI at Configuration->Security Profile->Firewall   
+
+Python dependencies 
+-------------------
+* suds-0.4
+
+* Installation procedure on Ubuntu/Debian
+
+::
+
+ easy_install suds==0.4
+
+
+Configuration flags required for nova-compute 
+---------------------------------------------
+::
+ 
+  --connection_type=vmwareapi 
+  --vmwareapi_host_ip=<VMware ESX Host IP> 
+  --vmwareapi_host_username=<VMware ESX Username>
+  --vmwareapi_host_password=<VMware ESX Password>
+  --network_driver=nova.network.vmwareapi_net [Optional, only for VLAN Networking]
+  --vlan_interface=<Physical ethernet adapter name in VMware ESX host for vlan networking E.g vmnic0> [Optional, only for VLAN Networking]
+  
+
+Configuration flags required for nova-network 
+---------------------------------------------
+::
+ 
+  --network_manager=nova.network.manager.FlatManager [or nova.network.manager.VlanManager]
+  --flat_network_bridge=<ESX Virtual Machine Port Group> [Optional, only for Flat Networking]
+
+
+Configuration flags required for nova-console
+---------------------------------------------
+::
+ 
+  --console_manager=nova.console.vmrc_manager.ConsoleVMRCManager
+  --console_driver=nova.console.vmrc.VMRCSessionConsole [Optional, only for OTP (One time Passwords) as against host credentials]
+
+   
+Other flags
+-----------
+::
+
+  --image_service=nova.image.glance.GlanceImageService
+  --glance_host=<Glance Host>
+  --vmwareapi_wsdl_loc=<http://<WEB SERVER>/vimService.wsdl>
+
+Note:- Due to a faulty wsdl being shipped with ESX vSphere 4.1 we need a working wsdl which can to be mounted on any webserver. Follow the below steps to download the SDK,
+
+* Go to http://www.vmware.com/support/developer/vc-sdk/
+* Go to section VMware vSphere Web Services SDK 4.0
+* Click "Downloads"
+* Enter VMware credentials when prompted for download
+* Unzip the downloaded file vi-sdk-4.0.0-xxx.zip
+* Go to SDK->WSDL->vim25 & host the files "vimService.wsdl" and "vim.wsdl" in a WEB SERVER
+* Set the flag "--vmwareapi_wsdl_loc" with url, "http://<WEB SERVER>/vimService.wsdl"
+
+
+VLAN Network Manager
+--------------------
+VLAN network support is added through a custom network driver in the nova-compute node i.e "nova.network.vmwareapi_net" and it uses a Physical ethernet adapter on the VMware ESX/ESXi host for VLAN Networking (the name of the ethernet adapter is specified as vlan_interface flag in the nova-compute configuration flag) in the nova-compute node.
+
+Using the physical adapter name the associated Virtual Switch will be determined. In VMware ESX there can be only one Virtual Switch associated with a Physical adapter.
+
+When VM Spawn request is issued with a VLAN ID the work flow looks like,
+
+1. Check that a Physical adapter with the given name exists. If no, throw an error.If yes, goto next step.
+
+2. Check if a Virtual Switch is associated with the Physical ethernet adapter with vlan interface name. If no, throw an error. If yes, goto next step.
+
+3. Check if a port group with the network bridge name exists. If no, create a port group in the Virtual switch with the give name and VLAN id and goto step 6. If yes, goto next step.
+
+4. Check if the port group is associated with the Virtual Switch. If no, throw an error. If yes, goto next step.
+
+5. Check if the port group is associated with the given VLAN Id. If no, throw an error. If yes, goto next step.
+
+6. Spawn the VM using this Port Group as the Network Name for the VM.
+
+
+Guest console Support
+---------------------
+| VMware VMRC console is a built-in console method providing graphical control of the VM remotely.
+|
+|        VMRC Console types supported:
+|            # Host based credentials
+|                Not secure (Sends ESX admin credentials in clear text)
+|
+|            # OTP (One time passwords)
+|                Secure but creates multiple session entries in DB for each OpenStack console create request.
+|                Console sessions created is can be used only once.
+|
+|        Install browser based VMware ESX plugins/activex on the client machine to connect
+|
+|            Windows:-
+|                Internet Explorer:
+|                    https://<VMware ESX Host>/ui/plugin/vmware-vmrc-win32-x86.exe
+|
+|                Mozilla Firefox:
+|                    https://<VMware ESX Host>/ui/plugin/vmware-vmrc-win32-x86.xpi
+|
+|            Linux:-
+|                Mozilla Firefox
+|                    32-Bit Linux:
+|                        https://<VMware ESX Host>/ui/plugin/vmware-vmrc-linux-x86.xpi
+|
+|                    64-Bit Linux:
+|                        https://<VMware ESX Host>/ui/plugin/vmware-vmrc-linux-x64.xpi
+|
+|        OpenStack Console Details:
+|            console_type = vmrc+credentials | vmrc+session
+|            host = <VMware ESX Host>
+|            port = <VMware ESX Port>
+|            password = {'vm_id': <VMware VM ID>,'username':<VMware ESX Username>, 'password':<VMware ESX Password>} //base64 + json encoded
+|
+|        Instantiate the plugin/activex object
+|            # In Internet Explorer
+|                <object id='vmrc' classid='CLSID:B94C2238-346E-4C5E-9B36-8CC627F35574'>
+|                </object>
+|
+|            # Mozilla Firefox and other browsers
+|                <object id='vmrc' type='application/x-vmware-vmrc;version=2.5.0.0'>
+|                </object>
+|
+|        Open vmrc connection
+|            # Host based credentials [type=vmrc+credentials]
+|                <script type="text/javascript">
+|                    var MODE_WINDOW = 2;
+|                    var vmrc = document.getElementById('vmrc');
+|                    vmrc.connect(<VMware ESX Host> + ':' + <VMware ESX Port>, <VMware ESX Username>, <VMware ESX Password>, '', <VMware VM ID>, MODE_WINDOW);
+|                </script>
+|
+|            # OTP (One time passwords) [type=vmrc+session]
+|                <script type="text/javascript">
+|                    var MODE_WINDOW = 2;
+|                    var vmrc = document.getElementById('vmrc');
+|                    vmrc.connectWithSession(<VMware ESX Host> + ':' + <VMware ESX Port>, <VMware VM ID>, <VMware ESX Password>, MODE_WINDOW);
+|                </script>
+
+
+Assumptions
+-----------
+1. The VMware images uploaded to the image repositories have VMware Tools installed.
+
+
+FAQ 
+---
+
+1. What type of disk images are supported?
+
+* Only VMware VMDK's are currently supported and of that support is available only for thick disks, thin provisioned disks are not supported.
+
+
+2. How is IP address information injected into the guest?
+
+* IP address information is injected through 'machine.id' vmx parameter (equivalent to XenStore in XenServer). This information can be retrived inside the guest using VMware tools.
+
+    
+3. What is the guest tool?
+
+* The guest tool is a small python script that should be run either as a service or added to system startup. This script configures networking on the guest. The guest tool is available at tools/esx/guest_tool.py
+
+
+4. What type of consoles are supported?
+
+* VMware VMRC based consoles are supported. There are 2 options for credentials one is OTP (Secure but creates multiple session entries in DB for each OpenStack console create request.) & other is host based credentials (It may not be secure as ESX credentials are transmitted as clear text).
+
+5. What does 'Vim' refer to as far as vmwareapi module is concerned?
+
+* Vim refers to VMware Virtual Infrastructure Methodology. This is not to be confused with "VIM" editor.
+
 
=== modified file 'etc/api-paste.ini'
--- etc/api-paste.ini	2011-03-07 19:33:24 +0000
+++ etc/api-paste.ini	2011-03-25 13:43:55 +0000
@@ -67,10 +67,14 @@
 [composite:osapi]
 use = egg:Paste#urlmap
 /: osversions
-/v1.0: openstackapi
-
-[pipeline:openstackapi]
-pipeline = faultwrap auth ratelimit osapiapp
+/v1.0: openstackapi10
+/v1.1: openstackapi11
+
+[pipeline:openstackapi10]
+pipeline = faultwrap auth ratelimit osapiapp10
+
+[pipeline:openstackapi11]
+pipeline = faultwrap auth ratelimit extensions osapiapp11
 
 [filter:faultwrap]
 paste.filter_factory = nova.api.openstack:FaultWrapper.factory
@@ -79,10 +83,16 @@
 paste.filter_factory = nova.api.openstack.auth:AuthMiddleware.factory
 
 [filter:ratelimit]
-paste.filter_factory = nova.api.openstack.ratelimiting:RateLimitingMiddleware.factory
-
-[app:osapiapp]
-paste.app_factory = nova.api.openstack:APIRouter.factory
+paste.filter_factory = nova.api.openstack.limits:RateLimitingMiddleware.factory
+
+[filter:extensions]
+paste.filter_factory = nova.api.openstack.extensions:ExtensionMiddleware.factory
+
+[app:osapiapp10]
+paste.app_factory = nova.api.openstack:APIRouterV10.factory
+
+[app:osapiapp11]
+paste.app_factory = nova.api.openstack:APIRouterV11.factory
 
 [pipeline:osversions]
 pipeline = faultwrap osversionapp
 
=== modified file 'nova/api/direct.py'
--- nova/api/direct.py	2011-03-09 20:08:11 +0000
+++ nova/api/direct.py	2011-03-25 13:43:55 +0000
@@ -38,6 +38,7 @@
 import webob
 
 from nova import context
+from nova import exception
 from nova import flags
 from nova import utils
 from nova import wsgi
@@ -205,10 +206,59 @@
         # 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)
+<<<<<<< TREE
         if type(result) is dict or type(result) is list:
             return self._serialize(result, req.best_match_content_type())
         else:
+=======
+        if result is None or type(result) is str or type(result) is unicode:
+>>>>>>> MERGE-SOURCE
             return result
+        try:
+            return self._serialize(result, req.best_match_content_type())
+        except:
+            raise exception.Error("returned non-serializable type: %s"
+                                  % result)
+
+
+class Limited(object):
+    __notdoc = """Limit the available methods on a given object.
+
+    (Not a docstring so that the docstring can be conditionally overriden.)
+
+    Useful when defining a public API that only exposes a subset of an
+    internal API.
+
+    Expected usage of this class is to define a subclass that lists the allowed
+    methods in the 'allowed' variable.
+
+    Additionally where appropriate methods can be added or overwritten, for
+    example to provide backwards compatibility.
+
+    The wrapping approach has been chosen so that the wrapped API can maintain
+    its own internal consistency, for example if it calls "self.create" it
+    should get its own create method rather than anything we do here.
+
+    """
+
+    _allowed = None
+
+    def __init__(self, proxy):
+        self._proxy = proxy
+        if not self.__doc__:
+            self.__doc__ = proxy.__doc__
+        if not self._allowed:
+            self._allowed = []
+
+    def __getattr__(self, key):
+        """Only return methods that are named in self._allowed."""
+        if key not in self._allowed:
+            raise AttributeError()
+        return getattr(self._proxy, key)
+
+    def __dir__(self):
+        """Only return methods that are named in self._allowed."""
+        return [x for x in dir(self._proxy) if x in self._allowed]
 
 
 class Proxy(object):
 
=== modified file 'nova/api/ec2/__init__.py'
--- nova/api/ec2/__init__.py	2011-03-09 19:20:26 +0000
+++ nova/api/ec2/__init__.py	2011-03-25 13:43:55 +0000
@@ -31,7 +31,7 @@
 from nova import utils
 from nova import wsgi
 from nova.api.ec2 import apirequest
-from nova.api.ec2 import cloud
+from nova.api.ec2 import ec2utils
 from nova.auth import manager
 
 
@@ -60,11 +60,22 @@
         self.log_request_completion(rv, req, start)
         return rv
 
+<<<<<<< TREE
     def log_request_completion(self, response, request, start):
         controller = request.environ.get('ec2.controller', None)
         if controller:
             controller = controller.__class__.__name__
         action = request.environ.get('ec2.action', None)
+=======
+    def log_request_completion(self, response, request, start):
+        apireq = request.environ.get('ec2.request', None)
+        if apireq:
+            controller = apireq.controller
+            action = apireq.action
+        else:
+            controller = None
+            action = None
+>>>>>>> MERGE-SOURCE
         ctxt = request.environ.get('ec2.context', None)
         delta = utils.utcnow() - start
         seconds = delta.seconds
@@ -75,7 +86,7 @@
             microseconds,
             request.remote_addr,
             request.method,
-            request.path_info,
+            "%s%s" % (request.script_name, request.path_info),
             controller,
             action,
             response.status_int,
@@ -319,13 +330,13 @@
         except exception.InstanceNotFound as ex:
             LOG.info(_('InstanceNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = cloud.id_to_ec2_id(ex.instance_id)
+            ec2_id = ec2utils.id_to_ec2_id(ex.instance_id)
             message = _('Instance %s not found') % ec2_id
             return self._error(req, context, type(ex).__name__, message)
         except exception.VolumeNotFound as ex:
             LOG.info(_('VolumeNotFound raised: %s'), unicode(ex),
                      context=context)
-            ec2_id = cloud.id_to_ec2_id(ex.volume_id, 'vol-%08x')
+            ec2_id = ec2utils.id_to_ec2_id(ex.volume_id, 'vol-%08x')
             message = _('Volume %s not found') % ec2_id
             return self._error(req, context, type(ex).__name__, message)
         except exception.NotFound as ex:
 
=== modified file 'nova/api/ec2/admin.py'
--- nova/api/ec2/admin.py	2011-03-03 00:12:22 +0000
+++ nova/api/ec2/admin.py	2011-03-25 13:43:55 +0000
@@ -27,7 +27,12 @@
 from nova import exception
 from nova import flags
 from nova import log as logging
-from nova import utils
+<<<<<<< TREE
+from nova import utils
+=======
+from nova import utils
+from nova.api.ec2 import ec2utils
+>>>>>>> MERGE-SOURCE
 from nova.auth import manager
 
 
@@ -60,6 +65,7 @@
 
 def host_dict(host, compute_service, instances, volume_service, volumes, now):
     """Convert a host model object to a result dict"""
+<<<<<<< TREE
     rv = {'hostanme': host, 'instance_count': len(instances),
           'volume_count': len(volumes)}
     if compute_service:
@@ -81,12 +87,36 @@
 
 def instance_dict(inst):
     return {'name': inst['name'],
+=======
+    rv = {'hostname': host, 'instance_count': len(instances),
+          'volume_count': len(volumes)}
+    if compute_service:
+        latest = compute_service['updated_at'] or compute_service['created_at']
+        delta = now - latest
+        if delta.seconds <= FLAGS.service_down_time:
+            rv['compute'] = 'up'
+        else:
+            rv['compute'] = 'down'
+    if volume_service:
+        latest = volume_service['updated_at'] or volume_service['created_at']
+        delta = now - latest
+        if delta.seconds <= FLAGS.service_down_time:
+            rv['volume'] = 'up'
+        else:
+            rv['volume'] = 'down'
+    return rv
+
+
+def instance_dict(inst):
+    return {'name': inst['name'],
+>>>>>>> MERGE-SOURCE
             'memory_mb': inst['memory_mb'],
             'vcpus': inst['vcpus'],
             'disk_gb': inst['local_gb'],
             'flavor_id': inst['flavorid']}
 
 
+<<<<<<< TREE
 def vpn_dict(project, vpn_instance):
     rv = {'project_id': project.id,
           'public_ip': project.vpn_ip,
@@ -106,6 +136,30 @@
     return rv
 
 
+=======
+def vpn_dict(project, vpn_instance):
+    rv = {'project_id': project.id,
+          'public_ip': project.vpn_ip,
+          'public_port': project.vpn_port}
+    if vpn_instance:
+        rv['instance_id'] = ec2utils.id_to_ec2_id(vpn_instance['id'])
+        rv['created_at'] = utils.isotime(vpn_instance['created_at'])
+        address = vpn_instance.get('fixed_ip', None)
+        if address:
+            rv['internal_ip'] = address['address']
+        if project.vpn_ip and project.vpn_port:
+            if utils.vpn_ping(project.vpn_ip, project.vpn_port):
+                rv['state'] = 'running'
+            else:
+                rv['state'] = 'down'
+        else:
+            rv['state'] = 'down - invalid project vpn config'
+    else:
+        rv['state'] = 'pending'
+    return rv
+
+
+>>>>>>> MERGE-SOURCE
 class AdminController(object):
     """
     API Controller for users, hosts, nodes, and workers.
@@ -114,9 +168,16 @@
     def __str__(self):
         return 'AdminController'
 
+<<<<<<< TREE
     def describe_instance_types(self, context, **_kwargs):
         """Returns all active instance types data (vcpus, memory, etc.)"""
         return {'instanceTypeSet': [db.instance_type_get_all(context)]}
+=======
+    def describe_instance_types(self, context, **_kwargs):
+        """Returns all active instance types data (vcpus, memory, etc.)"""
+        return {'instanceTypeSet': [instance_dict(v) for v in
+                                   db.instance_type_get_all(context).values()]}
+>>>>>>> MERGE-SOURCE
 
     def describe_user(self, _context, name, **_kwargs):
         """Returns user data, including access and secret keys."""
@@ -258,6 +319,7 @@
             raise exception.ApiError(_('operation must be add or remove'))
         return True
 
+<<<<<<< TREE
     def _vpn_for(self, context, project_id):
         """Get the VPN instance for a project ID."""
         for instance in db.instance_get_all_by_project(context, project_id):
@@ -288,6 +350,38 @@
             vpns.append(vpn_dict(project, instance))
         return {'items': vpns}
 
+=======
+    def _vpn_for(self, context, project_id):
+        """Get the VPN instance for a project ID."""
+        for instance in db.instance_get_all_by_project(context, project_id):
+            if (instance['image_id'] == FLAGS.vpn_image_id
+                and not instance['state_description'] in
+                    ['shutting_down', 'shutdown']):
+                return instance
+
+    def start_vpn(self, context, project):
+        instance = self._vpn_for(context, project)
+        if not instance:
+            # NOTE(vish) import delayed because of __init__.py
+            from nova.cloudpipe import pipelib
+            pipe = pipelib.CloudPipe()
+            try:
+                pipe.launch_vpn_instance(project)
+            except db.NoMoreNetworks:
+                raise exception.ApiError("Unable to claim IP for VPN instance"
+                                         ", ensure it isn't running, and try "
+                                         "again in a few minutes")
+            instance = self._vpn_for(context, project)
+        return {'instance_id': ec2utils.id_to_ec2_id(instance['id'])}
+
+    def describe_vpns(self, context):
+        vpns = []
+        for project in manager.AuthManager().get_projects():
+            instance = self._vpn_for(context, project.id)
+            vpns.append(vpn_dict(project, instance))
+        return {'items': vpns}
+
+>>>>>>> MERGE-SOURCE
     # FIXME(vish): these host commands don't work yet, perhaps some of the
     #              required data can be retrieved from service objects?
 
@@ -299,6 +393,7 @@
             * Volume (up, down, None)
             * Volume Count
         """
+<<<<<<< TREE
         services = db.service_get_all(context)
         now = datetime.datetime.utcnow()
         hosts = []
@@ -320,6 +415,29 @@
             rv.append(host_dict(host, compute, instances, volume, volumes,
                                 now))
         return {'hosts': rv}
+=======
+        services = db.service_get_all(context, False)
+        now = datetime.datetime.utcnow()
+        hosts = []
+        rv = []
+        for host in [service['host'] for service in services]:
+            if not host in hosts:
+                hosts.append(host)
+        for host in hosts:
+            compute = [s for s in services if s['host'] == host \
+                                           and s['binary'] == 'nova-compute']
+            if compute:
+                compute = compute[0]
+            instances = db.instance_get_all_by_host(context, host)
+            volume = [s for s in services if s['host'] == host \
+                                           and s['binary'] == 'nova-volume']
+            if volume:
+                volume = volume[0]
+            volumes = db.volume_get_all_by_host(context, host)
+            rv.append(host_dict(host, compute, instances, volume, volumes,
+                                now))
+        return {'hosts': rv}
+>>>>>>> MERGE-SOURCE
 
     def describe_host(self, _context, name, **_kwargs):
         """Returns status info for single node."""
 
=== modified file 'nova/api/ec2/cloud.py'
--- nova/api/ec2/cloud.py	2011-03-03 23:05:00 +0000
+++ nova/api/ec2/cloud.py	2011-03-25 13:43:55 +0000
@@ -145,10 +145,15 @@
         availability_zone = self._get_availability_zone_by_host(ctxt, host)
         floating_ip = db.instance_get_floating_address(ctxt,
                                                        instance_ref['id'])
+<<<<<<< TREE
         ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
         image_ec2_id = self._image_ec2_id(instance_ref['image_id'], 'machine')
         k_ec2_id = self._image_ec2_id(instance_ref['kernel_id'], 'kernel')
         r_ec2_id = self._image_ec2_id(instance_ref['ramdisk_id'], 'ramdisk')
+=======
+        ec2_id = ec2utils.id_to_ec2_id(instance_ref['id'])
+        image_ec2_id = self._image_ec2_id(instance_ref['image_id'], 'machine')
+>>>>>>> MERGE-SOURCE
         data = {
             'user-data': base64.b64decode(instance_ref['user_data']),
             'meta-data': {
@@ -167,8 +172,11 @@
                 'instance-type': instance_ref['instance_type'],
                 'local-hostname': hostname,
                 'local-ipv4': address,
+<<<<<<< TREE
                 'kernel-id': k_ec2_id,
                 'ramdisk-id': r_ec2_id,
+=======
+>>>>>>> MERGE-SOURCE
                 'placement': {'availability-zone': availability_zone},
                 'public-hostname': hostname,
                 'public-ipv4': floating_ip or '',
@@ -176,6 +184,13 @@
                 'reservation-id': instance_ref['reservation_id'],
                 'security-groups': '',
                 'mpi': mpi}}
+
+        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)
+                data['meta-data']['%s-id' % image_type] = ec2_id
+
         if False:  # TODO(vish): store ancestor ids
             data['ancestor-ami-ids'] = []
         if False:  # TODO(vish): store product codes
@@ -192,9 +207,15 @@
             return self._describe_availability_zones(context, **kwargs)
 
     def _describe_availability_zones(self, context, **kwargs):
+<<<<<<< TREE
         ctxt = context.elevated()
         enabled_services = db.service_get_all(ctxt)
         disabled_services = db.service_get_all(ctxt, True)
+=======
+        ctxt = context.elevated()
+        enabled_services = db.service_get_all(ctxt, False)
+        disabled_services = db.service_get_all(ctxt, True)
+>>>>>>> MERGE-SOURCE
         available_zones = []
         for zone in [service.availability_zone for service
                      in enabled_services]:
@@ -218,7 +239,7 @@
         rv = {'availabilityZoneInfo': [{'zoneName': 'nova',
                                         'zoneState': 'available'}]}
 
-        services = db.service_get_all(context)
+        services = db.service_get_all(context, False)
         now = datetime.datetime.utcnow()
         hosts = []
         for host in [service['host'] for service in services]:
@@ -537,8 +558,13 @@
         if volume_id:
             volumes = []
             for ec2_id in volume_id:
+<<<<<<< TREE
                 internal_id = ec2utils.ec2_id_to_id(ec2_id)
                 volume = self.volume_api.get(context, internal_id)
+=======
+                internal_id = ec2utils.ec2_id_to_id(ec2_id)
+                volume = self.volume_api.get(context, volume_id=internal_id)
+>>>>>>> MERGE-SOURCE
                 volumes.append(volume)
         else:
             volumes = self.volume_api.get_all(context)
@@ -582,9 +608,11 @@
 
     def create_volume(self, context, size, **kwargs):
         LOG.audit(_("Create volume of %s GB"), size, context=context)
-        volume = self.volume_api.create(context, size,
-                                        kwargs.get('display_name'),
-                                        kwargs.get('display_description'))
+        volume = self.volume_api.create(
+                context,
+                size=size,
+                name=kwargs.get('display_name'),
+                description=kwargs.get('display_description'))
         # TODO(vish): Instance should be None at db layer instead of
         #             trying to lazy load, but for now we turn it into
         #             a dict to avoid an error.
@@ -603,7 +631,9 @@
             if field in kwargs:
                 changes[field] = kwargs[field]
         if changes:
-            self.volume_api.update(context, volume_id, kwargs)
+            self.volume_api.update(context,
+                                   volume_id=volume_id,
+                                   fields=changes)
         return True
 
     def attach_volume(self, context, volume_id, instance_id, device, **kwargs):
@@ -616,7 +646,7 @@
                                        instance_id=instance_id,
                                        volume_id=volume_id,
                                        device=device)
-        volume = self.volume_api.get(context, volume_id)
+        volume = self.volume_api.get(context, volume_id=volume_id)
         return {'attachTime': volume['attach_time'],
                 'device': volume['mountpoint'],
                 'instanceId': ec2utils.id_to_ec2_id(instance_id),
@@ -627,7 +657,7 @@
     def detach_volume(self, context, volume_id, **kwargs):
         volume_id = ec2utils.ec2_id_to_id(volume_id)
         LOG.audit(_("Detach volume %s"), volume_id, context=context)
-        volume = self.volume_api.get(context, volume_id)
+        volume = self.volume_api.get(context, volume_id=volume_id)
         instance = self.compute_api.detach_volume(context, volume_id=volume_id)
         return {'attachTime': volume['attach_time'],
                 'device': volume['mountpoint'],
@@ -765,7 +795,7 @@
 
     def release_address(self, context, public_ip, **kwargs):
         LOG.audit(_("Release address %s"), public_ip, context=context)
-        self.network_api.release_floating_ip(context, public_ip)
+        self.network_api.release_floating_ip(context, address=public_ip)
         return {'releaseResponse': ["Address released."]}
 
     def associate_address(self, context, instance_id, public_ip, **kwargs):
@@ -779,7 +809,7 @@
 
     def disassociate_address(self, context, public_ip, **kwargs):
         LOG.audit(_("Disassociate address %s"), public_ip, context=context)
-        self.network_api.disassociate_floating_ip(context, public_ip)
+        self.network_api.disassociate_floating_ip(context, address=public_ip)
         return {'disassociateResponse': ["Address disassociated."]}
 
     def run_instances(self, context, **kwargs):
@@ -949,6 +979,7 @@
         if not operation_type in ['add', 'remove']:
             raise exception.ApiError(_('operation_type must be add or remove'))
         LOG.audit(_("Updating image %s publicity"), image_id, context=context)
+<<<<<<< TREE
 
         try:
             image = self._get_image(context, image_id)
@@ -959,6 +990,18 @@
         raise Exception(image)
         image['properties']['is_public'] = (operation_type == 'add')
         return self.image_service.update(context, internal_id, image)
+=======
+
+        try:
+            image = self._get_image(context, image_id)
+        except exception.NotFound:
+            raise exception.NotFound(_('Image %s not found') % image_id)
+        internal_id = image['id']
+        del(image['id'])
+
+        image['properties']['is_public'] = (operation_type == 'add')
+        return self.image_service.update(context, internal_id, image)
+>>>>>>> MERGE-SOURCE
 
     def update_image(self, context, image_id, **kwargs):
         internal_id = ec2utils.ec2_id_to_id(image_id)
 
=== modified file 'nova/api/openstack/__init__.py'
--- nova/api/openstack/__init__.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/__init__.py	2011-03-25 13:43:55 +0000
@@ -33,7 +33,9 @@
 from nova.api.openstack import consoles
 from nova.api.openstack import flavors
 from nova.api.openstack import images
+from nova.api.openstack import limits
 from nova.api.openstack import servers
+from nova.api.openstack import server_metadata
 from nova.api.openstack import shared_ip_groups
 from nova.api.openstack import users
 from nova.api.openstack import zones
@@ -70,10 +72,15 @@
         """Simple paste factory, :class:`nova.wsgi.Router` doesn't have one"""
         return cls()
 
-    def __init__(self):
+    def __init__(self, ext_mgr=None):
+        self.server_members = {}
         mapper = routes.Mapper()
+        self._setup_routes(mapper)
+        super(APIRouter, self).__init__(mapper)
 
-        server_members = {'action': 'POST'}
+    def _setup_routes(self, mapper):
+        server_members = self.server_members
+        server_members['action'] = 'POST'
         if FLAGS.allow_admin_api:
             LOG.debug(_("Including admin operations in API."))
 
@@ -83,6 +90,7 @@
             server_members['actions'] = 'GET'
             server_members['suspend'] = 'POST'
             server_members['resume'] = 'POST'
+<<<<<<< TREE
             server_members['rescue'] = 'POST'
             server_members['unrescue'] = 'POST'
             server_members['reset_network'] = 'POST'
@@ -101,6 +109,22 @@
         mapper.resource("server", "servers", controller=servers.Controller(),
                         collection={'detail': 'GET'},
                         member=server_members)
+=======
+            server_members['rescue'] = 'POST'
+            server_members['unrescue'] = 'POST'
+            server_members['reset_network'] = 'POST'
+            server_members['inject_network_info'] = 'POST'
+
+            mapper.resource("zone", "zones", controller=zones.Controller(),
+                        collection={'detail': 'GET', 'info': 'GET'}),
+
+            mapper.resource("user", "users", controller=users.Controller(),
+                        collection={'detail': 'GET'})
+
+            mapper.resource("account", "accounts",
+                            controller=accounts.Controller(),
+                            collection={'detail': 'GET'})
+>>>>>>> MERGE-SOURCE
 
         mapper.resource("backup_schedule", "backup_schedule",
                         controller=backup_schedules.Controller(),
@@ -114,13 +138,42 @@
 
         mapper.resource("image", "images", controller=images.Controller(),
                         collection={'detail': 'GET'})
+
         mapper.resource("flavor", "flavors", controller=flavors.Controller(),
                         collection={'detail': 'GET'})
+
         mapper.resource("shared_ip_group", "shared_ip_groups",
                         collection={'detail': 'GET'},
                         controller=shared_ip_groups.Controller())
 
-        super(APIRouter, self).__init__(mapper)
+        _limits = limits.LimitsController()
+        mapper.resource("limit", "limits", controller=_limits)
+
+
+class APIRouterV10(APIRouter):
+    """Define routes specific to OpenStack API V1.0."""
+
+    def _setup_routes(self, mapper):
+        super(APIRouterV10, self)._setup_routes(mapper)
+        mapper.resource("server", "servers",
+                        controller=servers.ControllerV10(),
+                        collection={'detail': 'GET'},
+                        member=self.server_members)
+
+
+class APIRouterV11(APIRouter):
+    """Define routes specific to OpenStack API V1.1."""
+
+    def _setup_routes(self, mapper):
+        super(APIRouterV11, self)._setup_routes(mapper)
+        mapper.resource("server", "servers",
+                        controller=servers.ControllerV11(),
+                        collection={'detail': 'GET'},
+                        member=self.server_members)
+        mapper.resource("server_meta", "meta",
+                        controller=server_metadata.Controller(),
+                        parent_resource=dict(member_name='server',
+                        collection_name='servers'))
 
 
 class Versions(wsgi.Application):
@@ -128,8 +181,11 @@
     def __call__(self, req):
         """Respond to a request for all OpenStack API versions."""
         response = {
-                "versions": [
-                    dict(status="CURRENT", id="v1.0")]}
+            "versions": [
+                dict(status="DEPRECATED", id="v1.0"),
+                dict(status="CURRENT", id="v1.1"),
+            ],
+        }
         metadata = {
             "application/xml": {
                 "attributes": dict(version=["status", "id"])}}
 
=== modified file 'nova/api/openstack/accounts.py'
--- nova/api/openstack/accounts.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/accounts.py	2011-03-25 13:43:55 +0000
@@ -1,85 +1,174 @@
-# 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 common
-
-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 faults
-
-FLAGS = flags.FLAGS
-LOG = logging.getLogger('nova.api.openstack')
-
-
-def _translate_keys(account):
-    return dict(id=account.id,
-                name=account.name,
-                description=account.description,
-                manager=account.project_manager_id)
-
-
-class Controller(wsgi.Controller):
-
-    _serialization_metadata = {
-        'application/xml': {
-            "attributes": {
-                "account": ["id", "name", "description", "manager"]}}}
-
-    def __init__(self):
-        self.manager = manager.AuthManager()
-
-    def _check_admin(self, context):
-        """We cannot depend on the db layer to check for admin access
-           for the auth manager, so we do it here"""
-        if not context.is_admin:
-            raise exception.NotAuthorized(_("Not admin user."))
-
-    def index(self, req):
-        raise faults.Fault(exc.HTTPNotImplemented())
-
-    def detail(self, req):
-        raise faults.Fault(exc.HTTPNotImplemented())
-
-    def show(self, req, id):
-        """Return data about the given account id"""
-        account = self.manager.get_project(id)
-        return dict(account=_translate_keys(account))
-
-    def delete(self, req, id):
-        self._check_admin(req.environ['nova.context'])
-        self.manager.delete_project(id)
-        return {}
-
-    def create(self, req):
-        """We use update with create-or-update semantics
-           because the id comes from an external source"""
-        raise faults.Fault(exc.HTTPNotImplemented())
-
-    def update(self, req, id):
-        """This is really create or update."""
-        self._check_admin(req.environ['nova.context'])
-        env = self._deserialize(req.body, req.get_content_type())
-        description = env['account'].get('description')
-        manager = env['account'].get('manager')
-        try:
-            account = self.manager.get_project(id)
-            self.manager.modify_project(id, manager, description)
-        except exception.NotFound:
-            account = self.manager.create_project(id, manager, description)
-        return dict(account=_translate_keys(account))
+<<<<<<< TREE
+# 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 common
+
+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 faults
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.api.openstack')
+
+
+def _translate_keys(account):
+    return dict(id=account.id,
+                name=account.name,
+                description=account.description,
+                manager=account.project_manager_id)
+
+
+class Controller(wsgi.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "account": ["id", "name", "description", "manager"]}}}
+
+    def __init__(self):
+        self.manager = manager.AuthManager()
+
+    def _check_admin(self, context):
+        """We cannot depend on the db layer to check for admin access
+           for the auth manager, so we do it here"""
+        if not context.is_admin:
+            raise exception.NotAuthorized(_("Not admin user."))
+
+    def index(self, req):
+        raise faults.Fault(exc.HTTPNotImplemented())
+
+    def detail(self, req):
+        raise faults.Fault(exc.HTTPNotImplemented())
+
+    def show(self, req, id):
+        """Return data about the given account id"""
+        account = self.manager.get_project(id)
+        return dict(account=_translate_keys(account))
+
+    def delete(self, req, id):
+        self._check_admin(req.environ['nova.context'])
+        self.manager.delete_project(id)
+        return {}
+
+    def create(self, req):
+        """We use update with create-or-update semantics
+           because the id comes from an external source"""
+        raise faults.Fault(exc.HTTPNotImplemented())
+
+    def update(self, req, id):
+        """This is really create or update."""
+        self._check_admin(req.environ['nova.context'])
+        env = self._deserialize(req.body, req.get_content_type())
+        description = env['account'].get('description')
+        manager = env['account'].get('manager')
+        try:
+            account = self.manager.get_project(id)
+            self.manager.modify_project(id, manager, description)
+        except exception.NotFound:
+            account = self.manager.create_project(id, manager, description)
+        return dict(account=_translate_keys(account))
+=======
+# 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 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 faults
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.api.openstack')
+
+
+def _translate_keys(account):
+    return dict(id=account.id,
+                name=account.name,
+                description=account.description,
+                manager=account.project_manager_id)
+
+
+class Controller(wsgi.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "account": ["id", "name", "description", "manager"]}}}
+
+    def __init__(self):
+        self.manager = manager.AuthManager()
+
+    def _check_admin(self, context):
+        """We cannot depend on the db layer to check for admin access
+           for the auth manager, so we do it here"""
+        if not context.is_admin:
+            raise exception.NotAuthorized(_("Not admin user."))
+
+    def index(self, req):
+        raise faults.Fault(webob.exc.HTTPNotImplemented())
+
+    def detail(self, req):
+        raise faults.Fault(webob.exc.HTTPNotImplemented())
+
+    def show(self, req, id):
+        """Return data about the given account id"""
+        account = self.manager.get_project(id)
+        return dict(account=_translate_keys(account))
+
+    def delete(self, req, id):
+        self._check_admin(req.environ['nova.context'])
+        self.manager.delete_project(id)
+        return {}
+
+    def create(self, req):
+        """We use update with create-or-update semantics
+           because the id comes from an external source"""
+        raise faults.Fault(webob.exc.HTTPNotImplemented())
+
+    def update(self, req, id):
+        """This is really create or update."""
+        self._check_admin(req.environ['nova.context'])
+        env = self._deserialize(req.body, req.get_content_type())
+        description = env['account'].get('description')
+        manager = env['account'].get('manager')
+        try:
+            account = self.manager.get_project(id)
+            self.manager.modify_project(id, manager, description)
+        except exception.NotFound:
+            account = self.manager.create_project(id, manager, description)
+        return dict(account=_translate_keys(account))
+>>>>>>> MERGE-SOURCE
 
=== modified file 'nova/api/openstack/auth.py'
--- nova/api/openstack/auth.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/auth.py	2011-03-25 13:43:55 +0000
@@ -135,8 +135,17 @@
         req - wsgi.Request object
         """
         ctxt = context.get_admin_context()
+<<<<<<< TREE
         user = self.auth.get_user_from_access_key(key)
 
+=======
+
+        try:
+            user = self.auth.get_user_from_access_key(key)
+        except exception.NotFound:
+            user = None
+
+>>>>>>> MERGE-SOURCE
         if user and user.name == username:
             token_hash = hashlib.sha1('%s%s%f' % (username, key,
                 time.time())).hexdigest()
 
=== modified file 'nova/api/openstack/common.py'
--- nova/api/openstack/common.py	2011-03-09 22:10:24 +0000
+++ nova/api/openstack/common.py	2011-03-25 13:43:55 +0000
@@ -15,9 +15,17 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+<<<<<<< TREE
 import webob.exc
 
+=======
+from urlparse import urlparse
+
+import webob
+
+>>>>>>> MERGE-SOURCE
 from nova import exception
+<<<<<<< TREE
 
 
 def limited(items, request, max_limit=1000):
@@ -50,10 +58,77 @@
         raise webob.exc.HTTPBadRequest(_('offset param must be positive'))
 
     limit = min(max_limit, limit or max_limit)
+=======
+from nova import flags
+
+FLAGS = flags.FLAGS
+
+
+def limited(items, request, max_limit=FLAGS.osapi_max_limit):
+    """
+    Return a slice of items according to requested offset and limit.
+
+    @param items: A sliceable entity
+    @param request: `wsgi.Request` possibly containing 'offset' and 'limit'
+                    GET variables. 'offset' is where to start in the list,
+                    and 'limit' is the maximum number of items to return. If
+                    'limit' is not specified, 0, or > max_limit, we default
+                    to max_limit. Negative values for either offset or limit
+                    will cause exc.HTTPBadRequest() exceptions to be raised.
+    @kwarg max_limit: The maximum number of items to return from 'items'
+    """
+    try:
+        offset = int(request.GET.get('offset', 0))
+    except ValueError:
+        raise webob.exc.HTTPBadRequest(_('offset param must be an integer'))
+
+    try:
+        limit = int(request.GET.get('limit', max_limit))
+    except ValueError:
+        raise webob.exc.HTTPBadRequest(_('limit param must be an integer'))
+
+    if limit < 0:
+        raise webob.exc.HTTPBadRequest(_('limit param must be positive'))
+
+    if offset < 0:
+        raise webob.exc.HTTPBadRequest(_('offset param must be positive'))
+
+    limit = min(max_limit, limit or max_limit)
+>>>>>>> MERGE-SOURCE
     range_end = offset + limit
     return items[offset:range_end]
 
 
+def limited_by_marker(items, request, max_limit=FLAGS.osapi_max_limit):
+    """Return a slice of items according to the requested marker and limit."""
+
+    try:
+        marker = int(request.GET.get('marker', 0))
+    except ValueError:
+        raise webob.exc.HTTPBadRequest(_('marker param must be an integer'))
+
+    try:
+        limit = int(request.GET.get('limit', max_limit))
+    except ValueError:
+        raise webob.exc.HTTPBadRequest(_('limit param must be an integer'))
+
+    if limit < 0:
+        raise webob.exc.HTTPBadRequest(_('limit param must be positive'))
+
+    limit = min(max_limit, limit)
+    start_index = 0
+    if marker:
+        start_index = -1
+        for i, item in enumerate(items):
+            if item['id'] == marker:
+                start_index = i + 1
+                break
+        if start_index < 0:
+            raise webob.exc.HTTPBadRequest(_('marker [%s] not found' % marker))
+    range_end = start_index + limit
+    return items[start_index:range_end]
+
+
 def get_image_id_from_image_hash(image_service, context, image_hash):
     """Given an Image ID Hash, return an objectstore Image ID.
 
@@ -74,3 +149,16 @@
         if abs(hash(image_id)) == int(image_hash):
             return image_id
     raise exception.NotFound(image_hash)
+
+
+def get_id_from_href(href):
+    """Return the id portion of a url as an int.
+
+    Given: http://www.foo.com/bar/123?q=4
+    Returns: 123
+
+    """
+    try:
+        return int(urlparse(href).path.split('/')[-1])
+    except:
+        raise webob.exc.HTTPBadRequest(_('could not parse id from href'))
 
=== added file 'nova/api/openstack/extensions.py'
--- nova/api/openstack/extensions.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/extensions.py	2011-03-25 13:43:55 +0000
@@ -0,0 +1,369 @@
+# 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 imp
+import os
+import sys
+import routes
+import webob.dec
+import webob.exc
+
+from nova import flags
+from nova import log as logging
+from nova import wsgi
+from nova.api.openstack import faults
+
+
+LOG = logging.getLogger('extensions')
+
+
+FLAGS = flags.FLAGS
+
+
+class ActionExtensionController(wsgi.Controller):
+
+    def __init__(self, application):
+
+        self.application = application
+        self.action_handlers = {}
+
+    def add_action(self, action_name, handler):
+        self.action_handlers[action_name] = handler
+
+    def action(self, req, id):
+
+        input_dict = self._deserialize(req.body, req.get_content_type())
+        for action_name, handler in self.action_handlers.iteritems():
+            if action_name in input_dict:
+                return handler(input_dict, req, id)
+        # no action handler found (bump to downstream application)
+        res = self.application
+        return res
+
+
+class ResponseExtensionController(wsgi.Controller):
+
+    def __init__(self, application):
+        self.application = application
+        self.handlers = []
+
+    def add_handler(self, handler):
+        self.handlers.append(handler)
+
+    def process(self, req, *args, **kwargs):
+        res = req.get_response(self.application)
+        content_type = req.best_match_content_type()
+        # currently response handlers are un-ordered
+        for handler in self.handlers:
+            res = handler(res)
+            try:
+                body = res.body
+                headers = res.headers
+            except AttributeError:
+                body = self._serialize(res, content_type)
+                headers = {"Content-Type": content_type}
+            res = webob.Response()
+            res.body = body
+            res.headers = headers
+        return res
+
+
+class ExtensionController(wsgi.Controller):
+
+    def __init__(self, extension_manager):
+        self.extension_manager = extension_manager
+
+    def _translate(self, ext):
+        ext_data = {}
+        ext_data['name'] = ext.get_name()
+        ext_data['alias'] = ext.get_alias()
+        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
+        return ext_data
+
+    def index(self, req):
+        extensions = []
+        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
+        ext = self.extension_manager.extensions[id]
+        return self._translate(ext)
+
+    def delete(self, req, id):
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def create(self, req):
+        raise faults.Fault(exc.HTTPNotFound())
+
+    def delete(self, req, id):
+        raise faults.Fault(exc.HTTPNotFound())
+
+
+class ExtensionMiddleware(wsgi.Middleware):
+    """
+    Extensions middleware that intercepts configured routes for extensions.
+    """
+    @classmethod
+    def factory(cls, global_config, **local_config):
+        """ 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
+        """
+        action_controllers = {}
+        for action in ext_mgr.get_actions():
+            if not action.collection in action_controllers.keys():
+                controller = ActionExtensionController(application)
+                mapper.connect("/%s/:(id)/action.:(format)" %
+                                action.collection,
+                                action='action',
+                                controller=controller,
+                                conditions=dict(method=['POST']))
+                mapper.connect("/%s/:(id)/action" % action.collection,
+                                action='action',
+                                controller=controller,
+                                conditions=dict(method=['POST']))
+                action_controllers[action.collection] = controller
+
+        return action_controllers
+
+    def _response_ext_controllers(self, application, ext_mgr, mapper):
+        """
+        Return a dict of ResponseExtensionController objects by collection
+        """
+        response_ext_controllers = {}
+        for resp_ext in ext_mgr.get_response_extensions():
+            if not resp_ext.key in response_ext_controllers.keys():
+                controller = ResponseExtensionController(application)
+                mapper.connect(resp_ext.url_route + '.:(format)',
+                                action='process',
+                                controller=controller,
+                                conditions=resp_ext.conditions)
+
+                mapper.connect(resp_ext.url_route,
+                                action='process',
+                                controller=controller,
+                                conditions=resp_ext.conditions)
+                response_ext_controllers[resp_ext.key] = controller
+
+        return response_ext_controllers
+
+    def __init__(self, application, ext_mgr=None):
+
+        if ext_mgr is None:
+            ext_mgr = ExtensionManager(FLAGS.osapi_extensions_path)
+        self.ext_mgr = ext_mgr
+
+        mapper = routes.Mapper()
+
+        # extended resources
+        for resource in ext_mgr.get_resources():
+            LOG.debug(_('Extended resource: %s'),
+                        resource.collection)
+            mapper.resource(resource.collection, resource.collection,
+                            controller=resource.controller,
+                            collection=resource.collection_actions,
+                            member=resource.member_actions,
+                            parent_resource=resource.parent)
+
+        # extended actions
+        action_controllers = self._action_ext_controllers(application, ext_mgr,
+                                                        mapper)
+        for action in ext_mgr.get_actions():
+            LOG.debug(_('Extended action: %s'), action.action_name)
+            controller = action_controllers[action.collection]
+            controller.add_action(action.action_name, action.handler)
+
+        # extended responses
+        resp_controllers = self._response_ext_controllers(application, ext_mgr,
+                                                            mapper)
+        for response_ext in ext_mgr.get_response_extensions():
+            LOG.debug(_('Extended response: %s'), response_ext.key)
+            controller = resp_controllers[response_ext.key]
+            controller.add_handler(response_ext.handler)
+
+        self._router = routes.middleware.RoutesMiddleware(self._dispatch,
+                                                          mapper)
+
+        super(ExtensionMiddleware, self).__init__(application)
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        """
+        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):
+        """
+        Returns the routed WSGI app's response or defers to the extended
+        application.
+        """
+        match = req.environ['wsgiorg.routing_args'][1]
+        if not match:
+            return req.environ['extended.app']
+        app = match['controller']
+        return app
+
+
+class ExtensionManager(object):
+    """
+    Load extensions from the configured extension path.
+    See nova/tests/api/openstack/extensions/foxinsocks.py for an example
+    extension implementation.
+    """
+
+    def __init__(self, path):
+        LOG.audit(_('Initializing extension manager.'))
+
+        self.path = path
+        self.extensions = {}
+        self._load_extensions()
+
+    def get_resources(self):
+        """
+        returns a list of ResourceExtension objects
+        """
+        resources = []
+        resources.append(ResourceExtension('extensions',
+                                            ExtensionController(self)))
+        for alias, ext in self.extensions.iteritems():
+            try:
+                resources.extend(ext.get_resources())
+            except AttributeError:
+                # NOTE: Extension aren't required to have resource extensions
+                pass
+        return resources
+
+    def get_actions(self):
+        """
+        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
+                pass
+        return actions
+
+    def get_response_extensions(self):
+        """
+        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
+                pass
+        return response_exts
+
+    def _check_extension(self, extension):
+        """
+        Checks for required methods in extension objects.
+        """
+        try:
+            LOG.debug(_('Ext name: %s'), extension.get_name())
+            LOG.debug(_('Ext alias: %s'), extension.get_alias())
+            LOG.debug(_('Ext description: %s'), extension.get_description())
+            LOG.debug(_('Ext namespace: %s'), extension.get_namespace())
+            LOG.debug(_('Ext updated: %s'), extension.get_updated())
+        except AttributeError as ex:
+            LOG.exception(_("Exception loading extension: %s"), unicode(ex))
+
+    def _load_extensions(self):
+        """
+        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'.
+
+        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):
+            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':
+                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))
+
+
+class ResponseExtension(object):
+    """
+    ResponseExtension objects can be used to add data to responses from
+    core nova OpenStack API controllers.
+    """
+
+    def __init__(self, method, url_route, handler):
+        self.url_route = url_route
+        self.handler = handler
+        self.conditions = dict(method=[method])
+        self.key = "%s-%s" % (method, url_route)
+
+
+class ActionExtension(object):
+    """
+    ActionExtension objects can be used to add custom actions to core nova
+    nova OpenStack API controllers.
+    """
+
+    def __init__(self, collection, action_name, handler):
+        self.collection = collection
+        self.action_name = action_name
+        self.handler = handler
+
+
+class ResourceExtension(object):
+    """
+    ResourceExtension objects can be used to add top level resources
+    to the OpenStack API in nova.
+    """
+
+    def __init__(self, collection, controller, parent=None,
+                 collection_actions={}, member_actions={}):
+        self.collection = collection
+        self.controller = controller
+        self.parent = parent
+        self.collection_actions = collection_actions
+        self.member_actions = member_actions
 
=== modified file 'nova/api/openstack/faults.py'
--- nova/api/openstack/faults.py	2011-03-09 20:08:11 +0000
+++ nova/api/openstack/faults.py	2011-03-25 13:43:55 +0000
@@ -57,7 +57,52 @@
             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)
-        content_type = req.best_match_content_type()
-        self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
+<<<<<<< TREE
+        serializer = wsgi.Serializer(metadata)
+        content_type = req.best_match_content_type()
+        self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
+=======
+        serializer = wsgi.Serializer(metadata)
+        content_type = req.best_match_content_type()
+        self.wrapped_exc.body = serializer.serialize(fault_data, content_type)
+        return self.wrapped_exc
+
+
+class OverLimitFault(webob.exc.HTTPException):
+    """
+    Rate-limited request response.
+    """
+
+    _serialization_metadata = {
+        "application/xml": {
+            "attributes": {
+                "overLimitFault": "code",
+            },
+        },
+    }
+
+    def __init__(self, message, details, retry_time):
+        """
+        Initialize new `OverLimitFault` with relevant information.
+        """
+        self.wrapped_exc = webob.exc.HTTPForbidden()
+        self.content = {
+            "overLimitFault": {
+                "code": self.wrapped_exc.status_int,
+                "message": message,
+                "details": details,
+            },
+        }
+
+    @webob.dec.wsgify(RequestClass=wsgi.Request)
+    def __call__(self, request):
+        """
+        Return the wrapped exception with a serialized body conforming to our
+        error format.
+        """
+        serializer = wsgi.Serializer(self._serialization_metadata)
+        content_type = request.best_match_content_type()
+        content = serializer.serialize(self.content, content_type)
+        self.wrapped_exc.body = content
+>>>>>>> MERGE-SOURCE
         return self.wrapped_exc
 
=== modified file 'nova/api/openstack/flavors.py'
--- nova/api/openstack/flavors.py	2011-03-09 18:10:45 +0000
+++ nova/api/openstack/flavors.py	2011-03-25 13:43:55 +0000
@@ -22,6 +22,7 @@
 from nova.api.openstack import faults
 from nova.api.openstack import common
 from nova.compute import instance_types
+from nova.api.openstack.views import flavors as flavors_views
 from nova import wsgi
 import nova.api.openstack
 
@@ -46,14 +47,33 @@
 
     def show(self, req, id):
         """Return data about the given flavor id."""
+<<<<<<< TREE
         ctxt = req.environ['nova.context']
         values = db.instance_type_get_by_flavor_id(ctxt, id)
         return dict(flavor=values)
         raise faults.Fault(exc.HTTPNotFound())
+=======
+        ctxt = req.environ['nova.context']
+        flavor = db.api.instance_type_get_by_flavor_id(ctxt, id)
+        values = {
+            "id": flavor["flavorid"],
+            "name": flavor["name"],
+            "ram": flavor["memory_mb"],
+            "disk": flavor["local_gb"],
+        }
+        return dict(flavor=values)
+>>>>>>> MERGE-SOURCE
 
     def _all_ids(self, req):
         """Return the list of all flavorids."""
+<<<<<<< TREE
         ctxt = req.environ['nova.context']
         inst_types = db.instance_type_get_all(ctxt)
         flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
         return sorted(flavor_ids)
+=======
+        ctxt = req.environ['nova.context']
+        inst_types = db.api.instance_type_get_all(ctxt)
+        flavor_ids = [inst_types[i]['flavorid'] for i in inst_types.keys()]
+        return sorted(flavor_ids)
+>>>>>>> MERGE-SOURCE
 
=== modified file 'nova/api/openstack/images.py'
--- nova/api/openstack/images.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/images.py	2011-03-25 13:43:55 +0000
@@ -15,10 +15,17 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+<<<<<<< TREE
+=======
+import datetime
+
+>>>>>>> MERGE-SOURCE
 from webob import 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
@@ -27,6 +34,8 @@
 import nova.image.service
 
 
+LOG = log.getLogger('nova.api.openstack.images')
+
 FLAGS = flags.FLAGS
 
 
@@ -84,8 +93,6 @@
         # S3ImageService
         pass
 
-    return item
-
 
 def _filter_keys(item, keys):
     """
@@ -104,6 +111,100 @@
         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):
 
     _serialization_metadata = {
@@ -117,33 +218,32 @@
 
     def index(self, req):
         """Return all public images in brief"""
-        items = self._service.index(req.environ['nova.context'])
-        items = common.limited(items, req)
-        items = [_filter_keys(item, ('id', 'name')) for item in items]
-        return dict(images=items)
+        context = req.environ['nova.context']
+        image_metas = self._service.index(context)
+        image_metas = common.limited(image_metas, req)
+        return dict(images=image_metas)
 
     def detail(self, req):
         """Return all public images in detail"""
-        try:
-            items = self._service.detail(req.environ['nova.context'])
-        except NotImplementedError:
-            items = self._service.index(req.environ['nova.context'])
-        for image in items:
-            _convert_image_id_to_hash(image)
-
-        items = common.limited(items, req)
-        items = [_translate_keys(item) for item in items]
-        items = [_translate_status(item) for item in items]
-        return dict(images=items)
+        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)
 
     def show(self, req, id):
         """Return data about the given image id"""
-        image_id = common.get_image_id_from_image_hash(self._service,
-                    req.environ['nova.context'], id)
+        context = req.environ['nova.context']
+        try:
+            image_id = common.get_image_id_from_image_hash(
+                self._service, context, id)
+        except exception.NotFound:
+            raise faults.Fault(exc.HTTPNotFound())
 
-        image = self._service.show(req.environ['nova.context'], image_id)
-        _convert_image_id_to_hash(image)
-        return dict(image=image)
+        image_meta = self._service.show(context, image_id)
+        api_image_meta = _safe_translate(image_meta)
+        return dict(image=api_image_meta)
 
     def delete(self, req, id):
         # Only public images are supported for now.
@@ -154,11 +254,10 @@
         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)
-
-        return dict(image=image_meta)
+        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
 
=== added file 'nova/api/openstack/limits.py'
--- nova/api/openstack/limits.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/limits.py	2011-03-25 13:43:55 +0000
@@ -0,0 +1,358 @@
+# 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 datetime
+
+"""
+Module dedicated functions/classes dealing with rate limiting requests.
+"""
+
+import copy
+import httplib
+import json
+import math
+import re
+import time
+import urllib
+import webob.exc
+
+from collections import defaultdict
+
+from webob.dec import wsgify
+
+from nova import wsgi
+from nova.api.openstack import faults
+from nova.wsgi import Controller
+from nova.wsgi import Middleware
+
+
+# Convenience constants for the limits dictionary passed to Limiter().
+PER_SECOND = 1
+PER_MINUTE = 60
+PER_HOUR = 60 * 60
+PER_DAY = 60 * 60 * 24
+
+
+class LimitsController(Controller):
+    """
+    Controller for accessing limits in the OpenStack API.
+    """
+
+    _serialization_metadata = {
+        "application/xml": {
+            "attributes": {
+                "limit": ["verb", "URI", "regex", "value", "unit",
+                    "resetTime", "remaining", "name"],
+            },
+            "plurals": {
+                "rate": "limit",
+            },
+        },
+    }
+
+    def index(self, req):
+        """
+        Return all global and rate limit information.
+        """
+        abs_limits = {}
+        rate_limits = req.environ.get("nova.limits", [])
+
+        return {
+            "limits": {
+                "rate": rate_limits,
+                "absolute": abs_limits,
+            },
+        }
+
+
+class Limit(object):
+    """
+    Stores information about a limit for HTTP requets.
+    """
+
+    UNITS = {
+        1: "SECOND",
+        60: "MINUTE",
+        60 * 60: "HOUR",
+        60 * 60 * 24: "DAY",
+    }
+
+    def __init__(self, verb, uri, regex, value, unit):
+        """
+        Initialize a new `Limit`.
+
+        @param verb: HTTP verb (POST, PUT, etc.)
+        @param uri: Human-readable URI
+        @param regex: Regular expression format for this limit
+        @param value: Integer number of requests which can be made
+        @param unit: Unit of measure for the value parameter
+        """
+        self.verb = verb
+        self.uri = uri
+        self.regex = regex
+        self.value = int(value)
+        self.unit = unit
+        self.unit_string = self.display_unit().lower()
+        self.remaining = int(value)
+
+        if value <= 0:
+            raise ValueError("Limit value must be > 0")
+
+        self.last_request = None
+        self.next_request = None
+
+        self.water_level = 0
+        self.capacity = self.unit
+        self.request_value = float(self.capacity) / float(self.value)
+        self.error_message = _("Only %(value)s %(verb)s request(s) can be "\
+            "made to %(uri)s every %(unit_string)s." % self.__dict__)
+
+    def __call__(self, verb, url):
+        """
+        Represents a call to this limit from a relevant request.
+
+        @param verb: string http verb (POST, GET, etc.)
+        @param url: string URL
+        """
+        if self.verb != verb or not re.match(self.regex, url):
+            return
+
+        now = self._get_time()
+
+        if self.last_request is None:
+            self.last_request = now
+
+        leak_value = now - self.last_request
+
+        self.water_level -= leak_value
+        self.water_level = max(self.water_level, 0)
+        self.water_level += self.request_value
+
+        difference = self.water_level - self.capacity
+
+        self.last_request = now
+
+        if difference > 0:
+            self.water_level -= self.request_value
+            self.next_request = now + difference
+            return difference
+
+        cap = self.capacity
+        water = self.water_level
+        val = self.value
+
+        self.remaining = math.floor(((cap - water) / cap) * val)
+        self.next_request = now
+
+    def _get_time(self):
+        """Retrieve the current time. Broken out for testability."""
+        return time.time()
+
+    def display_unit(self):
+        """Display the string name of the unit."""
+        return self.UNITS.get(self.unit, "UNKNOWN")
+
+    def display(self):
+        """Return a useful representation of this class."""
+        return {
+            "verb": self.verb,
+            "URI": self.uri,
+            "regex": self.regex,
+            "value": self.value,
+            "remaining": int(self.remaining),
+            "unit": self.display_unit(),
+            "resetTime": int(self.next_request or self._get_time()),
+        }
+
+# "Limit" format is a dictionary with the HTTP verb, human-readable URI,
+# a regular-expression to match, value and unit of measure (PER_DAY, etc.)
+
+DEFAULT_LIMITS = [
+    Limit("POST", "*", ".*", 10, PER_MINUTE),
+    Limit("POST", "*/servers", "^/servers", 50, PER_DAY),
+    Limit("PUT", "*", ".*", 10, PER_MINUTE),
+    Limit("GET", "*changes-since*", ".*changes-since.*", 3, PER_MINUTE),
+    Limit("DELETE", "*", ".*", 100, PER_MINUTE),
+]
+
+
+class RateLimitingMiddleware(Middleware):
+    """
+    Rate-limits requests passing through this middleware. All limit information
+    is stored in memory for this implementation.
+    """
+
+    def __init__(self, application, limits=None):
+        """
+        Initialize new `RateLimitingMiddleware`, which wraps the given WSGI
+        application and sets up the given limits.
+
+        @param application: WSGI application to wrap
+        @param limits: List of dictionaries describing limits
+        """
+        Middleware.__init__(self, application)
+        self._limiter = Limiter(limits or DEFAULT_LIMITS)
+
+    @wsgify(RequestClass=wsgi.Request)
+    def __call__(self, req):
+        """
+        Represents a single call through this middleware. We should record the
+        request if we have a limit relevant to it. If no limit is relevant to
+        the request, ignore it.
+
+        If the request should be rate limited, return a fault telling the user
+        they are over the limit and need to retry later.
+        """
+        verb = req.method
+        url = req.url
+        context = req.environ.get("nova.context")
+
+        if context:
+            username = context.user_id
+        else:
+            username = None
+
+        delay, error = self._limiter.check_for_delay(verb, url, username)
+
+        if delay:
+            msg = _("This request was rate-limited.")
+            retry = time.time() + delay
+            return faults.OverLimitFault(msg, error, retry)
+
+        req.environ["nova.limits"] = self._limiter.get_limits(username)
+
+        return self.application
+
+
+class Limiter(object):
+    """
+    Rate-limit checking class which handles limits in memory.
+    """
+
+    def __init__(self, limits):
+        """
+        Initialize the new `Limiter`.
+
+        @param limits: List of `Limit` objects
+        """
+        self.limits = copy.deepcopy(limits)
+        self.levels = defaultdict(lambda: copy.deepcopy(limits))
+
+    def get_limits(self, username=None):
+        """
+        Return the limits for a given user.
+        """
+        return [limit.display() for limit in self.levels[username]]
+
+    def check_for_delay(self, verb, url, username=None):
+        """
+        Check the given verb/user/user triplet for limit.
+
+        @return: Tuple of delay (in seconds) and error message (or None, None)
+        """
+        delays = []
+
+        for limit in self.levels[username]:
+            delay = limit(verb, url)
+            if delay:
+                delays.append((delay, limit.error_message))
+
+        if delays:
+            delays.sort()
+            return delays[0]
+
+        return None, None
+
+
+class WsgiLimiter(object):
+    """
+    Rate-limit checking from a WSGI application. Uses an in-memory `Limiter`.
+
+    To use:
+        POST /<username> with JSON data such as:
+        {
+            "verb" : GET,
+            "path" : "/servers"
+        }
+
+    and receive a 204 No Content, or a 403 Forbidden with an X-Wait-Seconds
+    header containing the number of seconds to wait before the action would
+    succeed.
+    """
+
+    def __init__(self, limits=None):
+        """
+        Initialize the new `WsgiLimiter`.
+
+        @param limits: List of `Limit` objects
+        """
+        self._limiter = Limiter(limits or DEFAULT_LIMITS)
+
+    @wsgify(RequestClass=wsgi.Request)
+    def __call__(self, request):
+        """
+        Handles a call to this application. Returns 204 if the request is
+        acceptable to the limiter, else a 403 is returned with a relevant
+        header indicating when the request *will* succeed.
+        """
+        if request.method != "POST":
+            raise webob.exc.HTTPMethodNotAllowed()
+
+        try:
+            info = dict(json.loads(request.body))
+        except ValueError:
+            raise webob.exc.HTTPBadRequest()
+
+        username = request.path_info_pop()
+        verb = info.get("verb")
+        path = info.get("path")
+
+        delay, error = self._limiter.check_for_delay(verb, path, username)
+
+        if delay:
+            headers = {"X-Wait-Seconds": "%.2f" % delay}
+            return webob.exc.HTTPForbidden(headers=headers, explanation=error)
+        else:
+            return webob.exc.HTTPNoContent()
+
+
+class WsgiLimiterProxy(object):
+    """
+    Rate-limit requests based on answers from a remote source.
+    """
+
+    def __init__(self, limiter_address):
+        """
+        Initialize the new `WsgiLimiterProxy`.
+
+        @param limiter_address: IP/port combination of where to request limit
+        """
+        self.limiter_address = limiter_address
+
+    def check_for_delay(self, verb, path, username=None):
+        body = json.dumps({"verb": verb, "path": path})
+        headers = {"Content-Type": "application/json"}
+
+        conn = httplib.HTTPConnection(self.limiter_address)
+
+        if username:
+            conn.request("POST", "/%s" % (username), body, headers)
+        else:
+            conn.request("POST", "/", body, headers)
+
+        resp = conn.getresponse()
+
+        if 200 >= resp.status < 300:
+            return None, None
+
+        return resp.getheader("X-Wait-Seconds"), resp.read() or None
 
=== added file 'nova/api/openstack/server_metadata.py'
--- nova/api/openstack/server_metadata.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/server_metadata.py	2011-03-25 13:43:55 +0000
@@ -0,0 +1,78 @@
+# 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.
+
+from webob import exc
+
+from nova import compute
+from nova import wsgi
+from nova.api.openstack import faults
+
+
+class Controller(wsgi.Controller):
+    """ The server metadata API controller for the Openstack API """
+
+    def __init__(self):
+        self.compute_api = compute.API()
+        super(Controller, self).__init__()
+
+    def _get_metadata(self, context, server_id):
+        metadata = self.compute_api.get_instance_metadata(context, server_id)
+        meta_dict = {}
+        for key, value in metadata.iteritems():
+            meta_dict[key] = value
+        return dict(metadata=meta_dict)
+
+    def index(self, req, server_id):
+        """ Returns the list of metadata for a given instance """
+        context = req.environ['nova.context']
+        return self._get_metadata(context, server_id)
+
+    def create(self, req, server_id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        self.compute_api.update_or_create_instance_metadata(context,
+                                                            server_id,
+                                                            body['metadata'])
+        return req.body
+
+    def update(self, req, server_id, id):
+        context = req.environ['nova.context']
+        body = self._deserialize(req.body, req.get_content_type())
+        if not id in body:
+            expl = _('Request body and URI mismatch')
+            raise exc.HTTPBadRequest(explanation=expl)
+        if len(body) > 1:
+            expl = _('Request body contains too many items')
+            raise exc.HTTPBadRequest(explanation=expl)
+        self.compute_api.update_or_create_instance_metadata(context,
+                                                            server_id,
+                                                            body)
+        return req.body
+
+    def show(self, req, server_id, id):
+        """ Return a single metadata item """
+        context = req.environ['nova.context']
+        data = self._get_metadata(context, server_id)
+        if id in data['metadata']:
+            return {id: data['metadata'][id]}
+        else:
+            return faults.Fault(exc.HTTPNotFound())
+
+    def delete(self, req, server_id, id):
+        """ Deletes an existing metadata """
+        context = req.environ['nova.context']
+        self.compute_api.delete_instance_metadata(context, server_id, id)
 
=== modified file 'nova/api/openstack/servers.py'
--- nova/api/openstack/servers.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/servers.py	2011-03-25 13:43:55 +0000
@@ -13,32 +13,48 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+<<<<<<< TREE
 import hashlib
 import json
+=======
+import base64
+import hashlib
+>>>>>>> MERGE-SOURCE
 import traceback
 
 from webob import exc
+from xml.dom import minidom
 
 from nova import compute
+from nova import context
 from nova import exception
 from nova import flags
 from nova import log as logging
+from nova import quota
+from nova import utils
 from nova import wsgi
-from nova import utils
 from nova.api.openstack import common
 from nova.api.openstack import faults
+import nova.api.openstack.views.addresses
+import nova.api.openstack.views.flavors
+import nova.api.openstack.views.servers
 from nova.auth import manager as auth_manager
 from nova.compute import instance_types
 from nova.compute import power_state
 import nova.api.openstack
+from nova.scheduler import api as scheduler_api
 
 
 LOG = logging.getLogger('server')
-
-
+<<<<<<< TREE
+
+
+=======
+>>>>>>> MERGE-SOURCE
 FLAGS = flags.FLAGS
 
 
+<<<<<<< TREE
 def _translate_detail_keys(inst):
     """ Coerces into dictionary format, mapping everything to Rackspace-like
     attributes for return"""
@@ -91,6 +107,8 @@
     return dict(server=dict(id=inst['id'], name=inst['display_name']))
 
 
+=======
+>>>>>>> MERGE-SOURCE
 class Controller(wsgi.Controller):
     """ The Server API controller for the OpenStack API """
 
@@ -98,39 +116,59 @@
         'application/xml': {
             "attributes": {
                 "server": ["id", "imageId", "name", "flavorId", "hostId",
+<<<<<<< TREE
                            "status", "progress", "adminPass"]}}}
+=======
+                           "status", "progress", "adminPass", "flavorRef",
+                           "imageRef"]}}}
+>>>>>>> MERGE-SOURCE
 
     def __init__(self):
         self.compute_api = compute.API()
         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, entity_maker=_translate_keys)
+        return self._items(req, is_detail=False)
 
     def detail(self, req):
         """ Returns a list of server details for a given user """
-        return self._items(req, entity_maker=_translate_detail_keys)
+        return self._items(req, is_detail=True)
 
-    def _items(self, req, entity_maker):
+    def _items(self, req, is_detail):
         """Returns a list of servers for a given user.
 
-        entity_maker - either _translate_detail_keys or _translate_keys
+        builder - the response model builder
         """
         instance_list = self.compute_api.get_all(req.environ['nova.context'])
-        limited_list = common.limited(instance_list, req)
-        res = [entity_maker(inst)['server'] for inst in limited_list]
-        return dict(servers=res)
+        limited_list = self._limit_items(instance_list, req)
+        builder = self._get_view_builder(req)
+        servers = [builder.build(inst, is_detail)['server']
+                for inst in limited_list]
+        return dict(servers=servers)
 
+    @scheduler_api.redirect_handler
     def show(self, req, id):
         """ Returns server details by server id """
         try:
-            instance = self.compute_api.get(req.environ['nova.context'], id)
-            return _translate_detail_keys(instance)
+            instance = self.compute_api.routing_get(
+                req.environ['nova.context'], id)
+            builder = self._get_view_builder(req)
+            return builder.build(instance, is_detail=True)
         except exception.NotFound:
             return faults.Fault(exc.HTTPNotFound())
 
+    @scheduler_api.redirect_handler
     def delete(self, req, id):
         """ Destroys a server """
         try:
@@ -141,20 +179,43 @@
 
     def create(self, req):
         """ Creates a new server for a given user """
+<<<<<<< TREE
         env = self._deserialize(req.body, req.get_content_type())
+=======
+        env = self._deserialize_create(req)
+>>>>>>> MERGE-SOURCE
         if not env:
             return faults.Fault(exc.HTTPUnprocessableEntity())
 
+<<<<<<< TREE
         context = req.environ['nova.context']
         key_pairs = auth_manager.AuthManager.get_key_pairs(context)
         if not key_pairs:
             raise exception.NotFound(_("No keypairs defined"))
         key_pair = key_pairs[0]
 
+=======
+        context = req.environ['nova.context']
+
+        key_name = None
+        key_data = None
+        key_pairs = auth_manager.AuthManager.get_key_pairs(context)
+        if key_pairs:
+            key_pair = key_pairs[0]
+            key_name = key_pair['name']
+            key_data = key_pair['public_key']
+
+        requested_image_id = self._image_id_from_req_data(env)
+>>>>>>> MERGE-SOURCE
         image_id = common.get_image_id_from_image_hash(self._image_service,
+<<<<<<< TREE
             context, env['server']['imageId'])
+=======
+            context, requested_image_id)
+>>>>>>> MERGE-SOURCE
         kernel_id, ramdisk_id = self._get_kernel_ramdisk_from_image(
             req, image_id)
+<<<<<<< TREE
 
         # Metadata is a list, not a Dictionary, because we allow duplicate keys
         # (even though JSON can't encode this)
@@ -187,6 +248,110 @@
                                             password)
         return server
 
+=======
+
+        # Metadata is a list, not a Dictionary, because we allow duplicate keys
+        # (even though JSON can't encode this)
+        # In future, we may not allow duplicate keys.
+        # However, the CloudServers API is not definitive on this front,
+        #  and we want to be compatible.
+        metadata = []
+        if env['server'].get('metadata'):
+            for k, v in env['server']['metadata'].items():
+                metadata.append({'key': k, 'value': v})
+
+        personality = env['server'].get('personality')
+        injected_files = []
+        if personality:
+            injected_files = self._get_injected_files(personality)
+
+        flavor_id = self._flavor_id_from_req_data(env)
+        try:
+            (inst,) = self.compute_api.create(
+                context,
+                instance_types.get_by_flavor_id(flavor_id),
+                image_id,
+                kernel_id=kernel_id,
+                ramdisk_id=ramdisk_id,
+                display_name=env['server']['name'],
+                display_description=env['server']['name'],
+                key_name=key_name,
+                key_data=key_data,
+                metadata=metadata,
+                injected_files=injected_files)
+        except quota.QuotaError as error:
+            self._handle_quota_error(error)
+
+        inst['instance_type'] = flavor_id
+        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))
+        server['server']['adminPass'] = password
+        self.compute_api.set_admin_password(context, server['server']['id'],
+                                            password)
+        return server
+
+    def _deserialize_create(self, request):
+        """
+        Deserialize a create request
+
+        Overrides normal behavior in the case of xml content
+        """
+        if request.content_type == "application/xml":
+            deserializer = ServerCreateRequestXMLDeserializer()
+            return deserializer.deserialize(request.body)
+        else:
+            return self._deserialize(request.body, request.get_content_type())
+
+    def _get_injected_files(self, personality):
+        """
+        Create a list of injected files from the personality attribute
+
+        At this time, injected_files must be formatted as a list of
+        (file_path, file_content) pairs for compatibility with the
+        underlying compute service.
+        """
+        injected_files = []
+
+        for item in personality:
+            try:
+                path = item['path']
+                contents = item['contents']
+            except KeyError as key:
+                expl = _('Bad personality format: missing %s') % key
+                raise exc.HTTPBadRequest(explanation=expl)
+            except TypeError:
+                expl = _('Bad personality format')
+                raise exc.HTTPBadRequest(explanation=expl)
+            try:
+                contents = base64.b64decode(contents)
+            except TypeError:
+                expl = _('Personality content for %s cannot be decoded') % path
+                raise exc.HTTPBadRequest(explanation=expl)
+            injected_files.append((path, contents))
+        return injected_files
+
+    def _handle_quota_error(self, error):
+        """
+        Reraise quota errors as api-specific http exceptions
+        """
+        if error.code == "OnsetFileLimitExceeded":
+            expl = _("Personality file limit exceeded")
+            raise exc.HTTPBadRequest(explanation=expl)
+        if error.code == "OnsetFilePathLimitExceeded":
+            expl = _("Personality file path too long")
+            raise exc.HTTPBadRequest(explanation=expl)
+        if error.code == "OnsetFileContentLimitExceeded":
+            expl = _("Personality file content too long")
+            raise exc.HTTPBadRequest(explanation=expl)
+        # if the original error is okay, just reraise it
+        raise error
+
+    @scheduler_api.redirect_handler
+>>>>>>> MERGE-SOURCE
     def update(self, req, id):
         """ Updates the server name or password """
         if len(req.body) == 0:
@@ -202,7 +367,7 @@
             update_dict['admin_pass'] = inst_dict['server']['adminPass']
             try:
                 self.compute_api.set_admin_password(ctxt, id)
-            except exception.TimeoutException, e:
+            except exception.TimeoutException:
                 return exc.HTTPRequestTimeout()
         if 'name' in inst_dict['server']:
             update_dict['display_name'] = inst_dict['server']['name']
@@ -212,6 +377,7 @@
             return faults.Fault(exc.HTTPNotFound())
         return exc.HTTPNoContent()
 
+    @scheduler_api.redirect_handler
     def action(self, req, id):
         """Multi-purpose method used to reboot, rebuild, or
         resize a server"""
@@ -277,6 +443,7 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def lock(self, req, id):
         """
         lock the instance with id
@@ -292,6 +459,7 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def unlock(self, req, id):
         """
         unlock the instance with id
@@ -307,6 +475,7 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def get_lock(self, req, id):
         """
         return the boolean state of (instance with id)'s lock
@@ -321,34 +490,68 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def reset_network(self, req, id):
-        """
-        Reset networking on an instance (admin only).
-
-        """
-        context = req.environ['nova.context']
-        try:
-            self.compute_api.reset_network(context, id)
-        except:
-            readable = traceback.format_exc()
-            LOG.exception(_("Compute.api::reset_network %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
-
-    def inject_network_info(self, req, id):
-        """
-        Inject network info for an instance (admin only).
-
-        """
-        context = req.environ['nova.context']
-        try:
-            self.compute_api.inject_network_info(context, id)
-        except:
-            readable = traceback.format_exc()
-            LOG.exception(_("Compute.api::inject_network_info %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
-
+<<<<<<< TREE
+    def reset_network(self, req, id):
+        """
+        Reset networking on an instance (admin only).
+
+        """
+        context = req.environ['nova.context']
+        try:
+            self.compute_api.reset_network(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("Compute.api::reset_network %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+    def inject_network_info(self, req, id):
+        """
+        Inject network info for an instance (admin only).
+
+        """
+        context = req.environ['nova.context']
+        try:
+            self.compute_api.inject_network_info(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("Compute.api::inject_network_info %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+=======
+    @scheduler_api.redirect_handler
+    def reset_network(self, req, id):
+        """
+        Reset networking on an instance (admin only).
+
+        """
+        context = req.environ['nova.context']
+        try:
+            self.compute_api.reset_network(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("Compute.api::reset_network %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+    @scheduler_api.redirect_handler
+    def inject_network_info(self, req, id):
+        """
+        Inject network info for an instance (admin only).
+
+        """
+        context = req.environ['nova.context']
+        try:
+            self.compute_api.inject_network_info(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("Compute.api::inject_network_info %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+    @scheduler_api.redirect_handler
+>>>>>>> MERGE-SOURCE
     def pause(self, req, id):
         """ Permit Admins to Pause the server. """
         ctxt = req.environ['nova.context']
@@ -360,6 +563,7 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def unpause(self, req, id):
         """ Permit Admins to Unpause the server. """
         ctxt = req.environ['nova.context']
@@ -371,6 +575,7 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def suspend(self, req, id):
         """permit admins to suspend the server"""
         context = req.environ['nova.context']
@@ -382,6 +587,7 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
+    @scheduler_api.redirect_handler
     def resume(self, req, id):
         """permit admins to resume the server from suspend"""
         context = req.environ['nova.context']
@@ -393,28 +599,56 @@
             return faults.Fault(exc.HTTPUnprocessableEntity())
         return exc.HTTPAccepted()
 
-    def rescue(self, req, id):
-        """Permit users to rescue the server."""
-        context = req.environ["nova.context"]
-        try:
-            self.compute_api.rescue(context, id)
-        except:
-            readable = traceback.format_exc()
-            LOG.exception(_("compute.api::rescue %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
-
-    def unrescue(self, req, id):
-        """Permit users to unrescue the server."""
-        context = req.environ["nova.context"]
-        try:
-            self.compute_api.unrescue(context, id)
-        except:
-            readable = traceback.format_exc()
-            LOG.exception(_("compute.api::unrescue %s"), readable)
-            return faults.Fault(exc.HTTPUnprocessableEntity())
-        return exc.HTTPAccepted()
-
+<<<<<<< TREE
+    def rescue(self, req, id):
+        """Permit users to rescue the server."""
+        context = req.environ["nova.context"]
+        try:
+            self.compute_api.rescue(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("compute.api::rescue %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+    def unrescue(self, req, id):
+        """Permit users to unrescue the server."""
+        context = req.environ["nova.context"]
+        try:
+            self.compute_api.unrescue(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("compute.api::unrescue %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+=======
+    @scheduler_api.redirect_handler
+    def rescue(self, req, id):
+        """Permit users to rescue the server."""
+        context = req.environ["nova.context"]
+        try:
+            self.compute_api.rescue(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("compute.api::rescue %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+    @scheduler_api.redirect_handler
+    def unrescue(self, req, id):
+        """Permit users to unrescue the server."""
+        context = req.environ["nova.context"]
+        try:
+            self.compute_api.unrescue(context, id)
+        except:
+            readable = traceback.format_exc()
+            LOG.exception(_("compute.api::unrescue %s"), readable)
+            return faults.Fault(exc.HTTPUnprocessableEntity())
+        return exc.HTTPAccepted()
+
+    @scheduler_api.redirect_handler
+>>>>>>> MERGE-SOURCE
     def get_ajax_console(self, req, id):
         """ Returns a url to an instance's ajaxterm console. """
         try:
@@ -424,6 +658,7 @@
             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"]
@@ -442,37 +677,195 @@
                 action=item.action,
                 error=item.error))
         return dict(actions=actions)
-
-    def _get_kernel_ramdisk_from_image(self, req, image_id):
-        """Retrevies kernel and ramdisk IDs from Glance
-
-        Only 'machine' (ami) type use kernel and ramdisk outside of the
-        image.
-        """
-        # FIXME(sirp): Since we're retrieving the kernel_id from an
-        # image_property, this means only Glance is supported.
-        # The BaseImageService needs to expose a consistent way of accessing
-        # kernel_id and ramdisk_id
-        image = self._image_service.show(req.environ['nova.context'], image_id)
-
-        if image['status'] != 'active':
-            raise exception.Invalid(
-                _("Cannot build from image %(image_id)s, status not active") %
-                  locals())
-
-        if image['disk_format'] != 'ami':
-            return None, None
-
-        try:
-            kernel_id = image['properties']['kernel_id']
-        except KeyError:
-            raise exception.NotFound(
-                _("Kernel not found for image %(image_id)s") % locals())
-
-        try:
-            ramdisk_id = image['properties']['ramdisk_id']
-        except KeyError:
-            raise exception.NotFound(
-                _("Ramdisk not found for image %(image_id)s") % locals())
-
-        return kernel_id, ramdisk_id
+<<<<<<< TREE
+
+    def _get_kernel_ramdisk_from_image(self, req, image_id):
+        """Retrevies kernel and ramdisk IDs from Glance
+
+        Only 'machine' (ami) type use kernel and ramdisk outside of the
+        image.
+        """
+        # FIXME(sirp): Since we're retrieving the kernel_id from an
+        # image_property, this means only Glance is supported.
+        # The BaseImageService needs to expose a consistent way of accessing
+        # kernel_id and ramdisk_id
+        image = self._image_service.show(req.environ['nova.context'], image_id)
+
+        if image['status'] != 'active':
+            raise exception.Invalid(
+                _("Cannot build from image %(image_id)s, status not active") %
+                  locals())
+
+        if image['disk_format'] != 'ami':
+            return None, None
+
+        try:
+            kernel_id = image['properties']['kernel_id']
+        except KeyError:
+            raise exception.NotFound(
+                _("Kernel not found for image %(image_id)s") % locals())
+
+        try:
+            ramdisk_id = image['properties']['ramdisk_id']
+        except KeyError:
+            raise exception.NotFound(
+                _("Ramdisk not found for image %(image_id)s") % locals())
+
+        return kernel_id, ramdisk_id
+=======
+
+    def _get_kernel_ramdisk_from_image(self, req, image_id):
+        """Retrevies kernel and ramdisk IDs from Glance
+
+        Only 'machine' (ami) type use kernel and ramdisk outside of the
+        image.
+        """
+        # FIXME(sirp): Since we're retrieving the kernel_id from an
+        # image_property, this means only Glance is supported.
+        # The BaseImageService needs to expose a consistent way of accessing
+        # kernel_id and ramdisk_id
+        image = self._image_service.show(req.environ['nova.context'], image_id)
+
+        if image['status'] != 'active':
+            raise exception.Invalid(
+                _("Cannot build from image %(image_id)s, status not active") %
+                  locals())
+
+        if image['disk_format'] != 'ami':
+            return None, None
+
+        try:
+            kernel_id = image['properties']['kernel_id']
+        except KeyError:
+            raise exception.NotFound(
+                _("Kernel not found for image %(image_id)s") % locals())
+
+        try:
+            ramdisk_id = image['properties']['ramdisk_id']
+        except KeyError:
+            raise exception.NotFound(
+                _("Ramdisk not found for image %(image_id)s") % locals())
+
+        return kernel_id, ramdisk_id
+
+
+class ControllerV10(Controller):
+    def _image_id_from_req_data(self, data):
+        return data['server']['imageId']
+
+    def _flavor_id_from_req_data(self, data):
+        return data['server']['flavorId']
+
+    def _get_view_builder(self, req):
+        addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV10()
+        return nova.api.openstack.views.servers.ViewBuilderV10(
+            addresses_builder)
+
+    def _get_addresses_view_builder(self, req):
+        return nova.api.openstack.views.addresses.ViewBuilderV10(req)
+
+    def _limit_items(self, items, req):
+        return common.limited(items, req)
+
+
+class ControllerV11(Controller):
+    def _image_id_from_req_data(self, data):
+        href = data['server']['imageRef']
+        return common.get_id_from_href(href)
+
+    def _flavor_id_from_req_data(self, data):
+        href = data['server']['flavorRef']
+        return common.get_id_from_href(href)
+
+    def _get_view_builder(self, req):
+        base_url = req.application_url
+        flavor_builder = nova.api.openstack.views.flavors.ViewBuilderV11(
+            base_url)
+        image_builder = nova.api.openstack.views.images.ViewBuilderV11(
+            base_url)
+        addresses_builder = nova.api.openstack.views.addresses.ViewBuilderV11()
+        return nova.api.openstack.views.servers.ViewBuilderV11(
+            addresses_builder, flavor_builder, image_builder)
+
+    def _get_addresses_view_builder(self, req):
+        return nova.api.openstack.views.addresses.ViewBuilderV11(req)
+
+    def _limit_items(self, items, req):
+        return common.limited_by_marker(items, req)
+
+
+class ServerCreateRequestXMLDeserializer(object):
+    """
+    Deserializer to handle xml-formatted server create requests.
+
+    Handles standard server attributes as well as optional metadata
+    and personality attributes
+    """
+
+    def deserialize(self, string):
+        """Deserialize an xml-formatted server create request"""
+        dom = minidom.parseString(string)
+        server = self._extract_server(dom)
+        return {'server': server}
+
+    def _extract_server(self, node):
+        """Marshal the server attribute of a parsed request"""
+        server = {}
+        server_node = self._find_first_child_named(node, 'server')
+        for attr in ["name", "imageId", "flavorId"]:
+            server[attr] = server_node.getAttribute(attr)
+        metadata = self._extract_metadata(server_node)
+        if metadata is not None:
+            server["metadata"] = metadata
+        personality = self._extract_personality(server_node)
+        if personality is not None:
+            server["personality"] = personality
+        return server
+
+    def _extract_metadata(self, server_node):
+        """Marshal the metadata attribute of a parsed request"""
+        metadata_node = self._find_first_child_named(server_node, "metadata")
+        if metadata_node is None:
+            return None
+        metadata = {}
+        for meta_node in self._find_children_named(metadata_node, "meta"):
+            key = meta_node.getAttribute("key")
+            metadata[key] = self._extract_text(meta_node)
+        return metadata
+
+    def _extract_personality(self, server_node):
+        """Marshal the personality attribute of a parsed request"""
+        personality_node = \
+                self._find_first_child_named(server_node, "personality")
+        if personality_node is None:
+            return None
+        personality = []
+        for file_node in self._find_children_named(personality_node, "file"):
+            item = {}
+            if file_node.hasAttribute("path"):
+                item["path"] = file_node.getAttribute("path")
+            item["contents"] = self._extract_text(file_node)
+            personality.append(item)
+        return personality
+
+    def _find_first_child_named(self, parent, name):
+        """Search a nodes children for the first child with a given name"""
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                return node
+        return None
+
+    def _find_children_named(self, parent, name):
+        """Return all of a nodes children who have the given name"""
+        for node in parent.childNodes:
+            if node.nodeName == name:
+                yield node
+
+    def _extract_text(self, node):
+        """Get the text field contained by the given node"""
+        if len(node.childNodes) == 1:
+            child = node.childNodes[0]
+            if child.nodeType == child.TEXT_NODE:
+                return child.nodeValue
+        return ""
+>>>>>>> MERGE-SOURCE
 
=== modified file 'nova/api/openstack/users.py'
--- nova/api/openstack/users.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/users.py	2011-03-25 13:43:55 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
@@ -91,3 +92,109 @@
         secret = env['user'].get('secret')
         self.manager.modify_user(id, access, secret, is_admin)
         return dict(user=_translate_keys(self.manager.get_user(id)))
+=======
+# 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.
+
+from webob import 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
+from nova.auth import manager
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.api.openstack')
+
+
+def _translate_keys(user):
+    return dict(id=user.id,
+                name=user.name,
+                access=user.access,
+                secret=user.secret,
+                admin=user.admin)
+
+
+class Controller(wsgi.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "user": ["id", "name", "access", "secret", "admin"]}}}
+
+    def __init__(self):
+        self.manager = manager.AuthManager()
+
+    def _check_admin(self, context):
+        """We cannot depend on the db layer to check for admin access
+           for the auth manager, so we do it here"""
+        if not context.is_admin:
+            raise exception.NotAuthorized(_("Not admin user"))
+
+    def index(self, req):
+        """Return all users in brief"""
+        users = self.manager.get_users()
+        users = common.limited(users, req)
+        users = [_translate_keys(user) for user in users]
+        return dict(users=users)
+
+    def detail(self, req):
+        """Return all users in detail"""
+        return self.index(req)
+
+    def show(self, req, id):
+        """Return data about the given user id"""
+
+        #NOTE(justinsb): The drivers are a little inconsistent in how they
+        #  deal with "NotFound" - some throw, some return None.
+        try:
+            user = self.manager.get_user(id)
+        except exception.NotFound:
+            user = None
+
+        if user is None:
+            raise faults.Fault(exc.HTTPNotFound())
+
+        return dict(user=_translate_keys(user))
+
+    def delete(self, req, id):
+        self._check_admin(req.environ['nova.context'])
+        self.manager.delete_user(id)
+        return {}
+
+    def create(self, req):
+        self._check_admin(req.environ['nova.context'])
+        env = self._deserialize(req.body, req.get_content_type())
+        is_admin = env['user'].get('admin') in ('T', 'True', True)
+        name = env['user'].get('name')
+        access = env['user'].get('access')
+        secret = env['user'].get('secret')
+        user = self.manager.create_user(name, access, secret, is_admin)
+        return dict(user=_translate_keys(user))
+
+    def update(self, req, id):
+        self._check_admin(req.environ['nova.context'])
+        env = self._deserialize(req.body, req.get_content_type())
+        is_admin = env['user'].get('admin')
+        if is_admin is not None:
+            is_admin = is_admin in ('T', 'True', True)
+        access = env['user'].get('access')
+        secret = env['user'].get('secret')
+        self.manager.modify_user(id, access, secret, is_admin)
+        return dict(user=_translate_keys(self.manager.get_user(id)))
+>>>>>>> MERGE-SOURCE
 
=== added directory 'nova/api/openstack/views'
=== added file 'nova/api/openstack/views/__init__.py'
=== added file 'nova/api/openstack/views/addresses.py'
--- nova/api/openstack/views/addresses.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/views/addresses.py	2011-03-25 13:43:55 +0000
@@ -0,0 +1,42 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# 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.
+
+from nova import utils
+from nova.api.openstack import common
+
+
+class ViewBuilder(object):
+    ''' Models a server addresses response as a python dictionary.'''
+
+    def build(self, inst):
+        raise NotImplementedError()
+
+
+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')
+        return dict(public=public_ips, private=private_ips)
+
+
+class ViewBuilderV11(ViewBuilder):
+    def build(self, inst):
+        private_ips = utils.get_from_path(inst, 'fixed_ip/address')
+        private_ips = [dict(version=4, addr=a) for a in private_ips]
+        public_ips = utils.get_from_path(inst, 'fixed_ip/floating_ips/address')
+        public_ips = [dict(version=4, addr=a) for a in public_ips]
+        return dict(public=public_ips, private=private_ips)
 
=== added file 'nova/api/openstack/views/flavors.py'
--- nova/api/openstack/views/flavors.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/views/flavors.py	2011-03-25 13:43:55 +0000
@@ -0,0 +1,34 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# 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.
+
+from nova.api.openstack import common
+
+
+class ViewBuilder(object):
+    def __init__(self):
+        pass
+
+    def build(self, flavor_obj):
+        raise NotImplementedError()
+
+
+class ViewBuilderV11(ViewBuilder):
+    def __init__(self, base_url):
+        self.base_url = base_url
+
+    def generate_href(self, flavor_id):
+        return "%s/flavors/%s" % (self.base_url, flavor_id)
 
=== added file 'nova/api/openstack/views/images.py'
--- nova/api/openstack/views/images.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/views/images.py	2011-03-25 13:43:55 +0000
@@ -0,0 +1,34 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# 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.
+
+from nova.api.openstack import common
+
+
+class ViewBuilder(object):
+    def __init__(self):
+        pass
+
+    def build(self, image_obj):
+        raise NotImplementedError()
+
+
+class ViewBuilderV11(ViewBuilder):
+    def __init__(self, base_url):
+        self.base_url = base_url
+
+    def generate_href(self, image_id):
+        return "%s/images/%s" % (self.base_url, image_id)
 
=== added file 'nova/api/openstack/views/servers.py'
--- nova/api/openstack/views/servers.py	1970-01-01 00:00:00 +0000
+++ nova/api/openstack/views/servers.py	2011-03-25 13:43:55 +0000
@@ -0,0 +1,125 @@
+# vim: tabstop=4 shiftwidth=4 softtabstop=4
+
+# 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.
+
+import hashlib
+
+from nova.compute import power_state
+import nova.compute
+import nova.context
+from nova.api.openstack import common
+from nova.api.openstack.views import addresses as addresses_view
+from nova.api.openstack.views import flavors as flavors_view
+from nova.api.openstack.views import images as images_view
+from nova import utils
+
+
+class ViewBuilder(object):
+    """Model a server response as a python dictionary.
+
+    Public methods: build
+    Abstract methods: _build_image, _build_flavor
+
+    """
+
+    def __init__(self, addresses_builder):
+        self.addresses_builder = addresses_builder
+
+    def build(self, inst, is_detail):
+        """Return a dict that represenst a server."""
+        if is_detail:
+            return self._build_detail(inst)
+        else:
+            return self._build_simple(inst)
+
+    def _build_simple(self, inst):
+        """Return a simple model of a server."""
+        return dict(server=dict(id=inst['id'], name=inst['display_name']))
+
+    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'}
+
+        inst_dict = {
+            'id': int(inst['id']),
+            'name': inst['display_name'],
+            'addresses': self.addresses_builder.build(inst),
+            'status': power_mapping[inst.get('state')]}
+
+        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'
+
+        # Return the metadata as a dictionary
+        metadata = {}
+        for item in inst.get('metadata', []):
+            metadata[item['key']] = item['value']
+        inst_dict['metadata'] = metadata
+
+        inst_dict['hostId'] = ''
+        if inst.get('host'):
+            inst_dict['hostId'] = hashlib.sha224(inst['host']).hexdigest()
+
+        self._build_image(inst_dict, inst)
+        self._build_flavor(inst_dict, inst)
+
+        return dict(server=inst_dict)
+
+    def _build_image(self, response, inst):
+        """Return the image sub-resource of a server."""
+        raise NotImplementedError()
+
+    def _build_flavor(self, response, inst):
+        """Return the flavor sub-resource of a server."""
+        raise NotImplementedError()
+
+
+class ViewBuilderV10(ViewBuilder):
+    """Model an Openstack API V1.0 server response."""
+
+    def _build_image(self, response, inst):
+        response['imageId'] = inst['image_id']
+
+    def _build_flavor(self, response, inst):
+        response['flavorId'] = inst['instance_type']
+
+
+class ViewBuilderV11(ViewBuilder):
+    """Model an Openstack API V1.0 server response."""
+
+    def __init__(self, addresses_builder, flavor_builder, image_builder):
+        ViewBuilder.__init__(self, addresses_builder)
+        self.flavor_builder = flavor_builder
+        self.image_builder = image_builder
+
+    def _build_image(self, response, inst):
+        image_id = inst["image_id"]
+        response["imageRef"] = self.image_builder.generate_href(image_id)
+
+    def _build_flavor(self, response, inst):
+        flavor_id = inst["instance_type"]
+        response["flavorRef"] = self.flavor_builder.generate_href(flavor_id)
 
=== modified file 'nova/api/openstack/zones.py'
--- nova/api/openstack/zones.py	2011-03-11 19:49:32 +0000
+++ nova/api/openstack/zones.py	2011-03-25 13:43:55 +0000
@@ -1,3 +1,4 @@
+<<<<<<< TREE
 # Copyright 2011 OpenStack LLC.
 # All Rights Reserved.
 #
@@ -93,3 +94,106 @@
         zone_id = int(id)
         zone = db.zone_update(context, zone_id, env["zone"])
         return dict(zone=_scrub_zone(zone))
+=======
+# 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 common
+
+from nova import db
+from nova import flags
+from nova import log as logging
+from nova import wsgi
+from nova.scheduler import api
+
+
+FLAGS = flags.FLAGS
+
+
+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 _exclude_keys(item, keys):
+    return dict((k, v) for k, v in item.iteritems() if k not in keys)
+
+
+def _scrub_zone(zone):
+    return _exclude_keys(zone, ('username', 'password', 'created_at',
+                    'deleted', 'deleted_at', 'updated_at'))
+
+
+class Controller(wsgi.Controller):
+
+    _serialization_metadata = {
+        'application/xml': {
+            "attributes": {
+                "zone": ["id", "api_url", "name", "capabilities"]}}}
+
+    def index(self, req):
+        """Return all zones in brief"""
+        # Ask the ZoneManager in the Scheduler for most recent data,
+        # or fall-back to the database ...
+        items = api.get_zone_list(req.environ['nova.context'])
+        items = common.limited(items, req)
+        items = [_scrub_zone(item) for item in items]
+        return dict(zones=items)
+
+    def detail(self, req):
+        """Return all zones in detail"""
+        return self.index(req)
+
+    def info(self, req):
+        """Return name and capabilities for this zone."""
+        items = api.get_zone_capabilities(req.environ['nova.context'])
+
+        zone = dict(name=FLAGS.zone_name)
+        caps = FLAGS.zone_capabilities
+        for cap in caps:
+            key, value = cap.split('=')
+            zone[key] = value
+        for item, (min_value, max_value) in items.iteritems():
+            zone[item] = "%s,%s" % (min_value, max_value)
+        return dict(zone=zone)
+
+    def show(self, req, id):
+        """Return data about the given zone id"""
+        zone_id = int(id)
+        zone = api.zone_get(req.environ['nova.context'], zone_id)
+        return dict(zone=_scrub_zone(zone))
+
+    def delete(self, req, id):
+        zone_id = int(id)
+        api.zone_delete(req.environ['nova.context'], zone_id)
+        return {}
+
+    def create(self, req):
+        context = req.environ['nova.context']
+        env = self._deserialize(req.body, req.get_content_type())
+        zone = api.zone_create(context, env["zone"])
+        return dict(zone=_scrub_zone(zone))
+
+    def update(self, req, id):
+        context = req.environ['nova.context']
+        env = self._deserialize(req.body, req.get_content_type())
+        zone_id = int(id)
+        zone = api.zone_update(context, zone_id, env["zone"])
+        return dict(zone=_scrub_zone(zone))
+>>>>>>> MERGE-SOURCE
 
=== modified file 'nova/auth/dbdriver.py'
--- nova/auth/dbdriver.py	2011-01-20 17:52:02 +0000
+++ nova/auth/dbdriver.py	2011-03-25 13:43:55 +0000
@@ -162,6 +162,8 @@
             values['description'] = description
 
         db.project_update(context.get_admin_context(), project_id, values)
+        if not self.is_in_project(manager_uid, project_id):
+            self.add_to_project(manager_uid, project_id)
 
     def add_to_project(self, uid, project_id):
         """Add user to project"""
 
=== modified file 'nova/auth/fakeldap.py'
--- nova/auth/fakeldap.py	2010-12-22 23:47:31 +0000
+++ nova/auth/fakeldap.py	2011-03-25 13:43:55 +0000
@@ -90,12 +90,12 @@
 MOD_REPLACE = 2
 
 
-class NO_SUCH_OBJECT(Exception):  # pylint: disable-msg=C0103
+class NO_SUCH_OBJECT(Exception):  # pylint: disable=C0103
     """Duplicate exception class from real LDAP module."""
     pass
 
 
-class OBJECT_CLASS_VIOLATION(Exception):  # pylint: disable-msg=C0103
+class OBJECT_CLASS_VIOLATION(Exception):  # pylint: disable=C0103
     """Duplicate exception class from real LDAP module."""
     pass
 
@@ -268,7 +268,7 @@
             # get the attributes from the store
             attrs = store.hgetall(key)
             # turn the values from the store into lists
-            # pylint: disable-msg=E1103
+            # pylint: disable=E1103
             attrs = dict([(k, _from_json(v))
                           for k, v in attrs.iteritems()])
             # filter the objects by query
@@ -277,12 +277,12 @@
                 attrs = dict([(k, v) for k, v in attrs.iteritems()
                               if not fields or k in fields])
                 objects.append((key[len(self.__prefix):], attrs))
-            # pylint: enable-msg=E1103
+            # pylint: enable=E1103
         if objects == []:
             raise NO_SUCH_OBJECT()
         return objects
 
     @property
-    def __prefix(self):  # pylint: disable-msg=R0201
+    def __prefix(self):  # pylint: disable=R0201
         """Get the prefix to use for all keys."""
         return 'ldap:'
 
=== modified file 'nova/auth/ldapdriver.py'
--- nova/auth/ldapdriver.py	2011-02-16 20:03:59 +0000
+++ nova/auth/ldapdriver.py	2011-03-25 13:43:55 +0000
@@ -275,6 +275,8 @@
             attr.append((self.ldap.MOD_REPLACE, 'description', description))
         dn = self.__project_to_dn(project_id)
         self.conn.modify_s(dn, attr)
+        if not self.is_in_project(manager_uid, project_id):
+            self.add_to_project(manager_uid, project_id)
 
     @sanitize
     def add_to_project(self, uid, project_id):
@@ -632,6 +634,6 @@
 class FakeLdapDriver(LdapDriver):
     """Fake Ldap Auth driver"""
 
-    def __init__(self):  # pylint: disable-msg=W0231
+    def __init__(self):  # pylint: disable=W0231
         __import__('nova.auth.fakeldap')
         self.ldap = sys.modules['nova.auth.fakeldap']
 
=== modified file 'nova/auth/manager.py'
--- nova/auth/manager.py	2011-01-19 02:00:28 +0000
+++ nova/auth/manager.py	2011-03-25 13:43:55 +0000
@@ -22,7 +22,7 @@
 
 import os
 import shutil
-import string  # pylint: disable-msg=W0402
+import string  # pylint: disable=W0402
 import tempfile
 import uuid
 import zipfile
@@ -96,10 +96,19 @@
 
 
 class User(AuthBase):
-    """Object representing a user"""
+    """Object representing a user
+
+    The following attributes are defined:
+    :id:       A system identifier for the user.  A string (for LDAP)
+    :name:     The user name, potentially in some more friendly format
+    :access:   The 'username' for EC2 authentication
+    :secret:   The 'password' for EC2 authenticatoin
+    :admin:    ???
+    """
 
     def __init__(self, id, name, access, secret, admin):
         AuthBase.__init__(self)
+        assert isinstance(id, basestring)
         self.id = id
         self.name = name
         self.access = access
 
=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-03-10 17:30:26 +0000
+++ nova/compute/api.py	2011-03-25 13:43:55 +0000
@@ -34,6 +34,7 @@
 from nova import utils
 from nova import volume
 from nova.compute import instance_types
+from nova.scheduler import api as scheduler_api
 from nova.db import base
 
 FLAGS = flags.FLAGS
@@ -80,13 +81,37 @@
                         topic,
                         {"method": "get_network_topic", "args": {'fake': 1}})
 
+    def _check_injected_file_quota(self, context, injected_files):
+        """
+        Enforce quota limits on injected files
+
+        Raises a QuotaError if any limit is exceeded
+        """
+        if injected_files is None:
+            return
+        limit = quota.allowed_injected_files(context)