From 7620db9454dd391ce3080e99cdb8237eaa9a4835 Mon Sep 17 00:00:00 2001
From: Johannes Erdfelt <johannes.erdfelt@rackspace.com>
Date: Wed, 15 Jun 2011 22:28:32 +0000
Subject: Windows instances will often take a few minutes setting up the image
 on first boot and then reboot. We should be more patient for those systems as
 well check if the domid changes so we can send agent requests to the current
 domid

---
 nova/virt/xenapi/vmops.py | 60 ++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 49 insertions(+), 11 deletions(-)

diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 6b61ca9b5..190bf7c20 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -25,6 +25,7 @@ import M2Crypto
 import os
 import pickle
 import subprocess
+import time
 import uuid
 
 from nova import context
@@ -44,7 +45,10 @@ from nova.virt.xenapi.vm_utils import ImageType
 
 XenAPI = None
 LOG = logging.getLogger("nova.virt.xenapi.vmops")
+
 FLAGS = flags.FLAGS
+flags.DEFINE_integer('windows_version_timeout', 300,
+                     'time to wait for windows agent to be fully operational')
 
 
 def _cmp_version(a, b):
@@ -244,7 +248,16 @@ class VMOps(object):
                         'architecture': instance.architecture})
 
         def _check_agent_version():
-            version = self.get_agent_version(instance)
+            if instance.os_type == 'windows':
+                # Windows will generally perform a setup process on first boot
+                # that can take a couple of minutes and then reboot. So we
+                # need to be more patient than normal as well as watch for
+                # domid changes
+                version = self.get_agent_version(instance,
+                                  timeout=FLAGS.windows_version_timeout,
+                                  check_domid_changes=True)
+            else:
+                version = self.get_agent_version(instance)
             if not version:
                 LOG.info(_('No agent version returned by instance'))
                 return
@@ -500,18 +513,43 @@ class VMOps(object):
         task = self._session.call_xenapi('Async.VM.clean_reboot', vm_ref)
         self._session.wait_for_task(task, instance.id)
 
-    def get_agent_version(self, instance):
+    def get_agent_version(self, instance, timeout=None,
+                          check_domid_changes=False):
         """Get the version of the agent running on the VM instance."""
 
-        # Send the encrypted password
-        transaction_id = str(uuid.uuid4())
-        args = {'id': transaction_id}
-        resp = self._make_agent_call('version', instance, '', args)
-        if resp is None:
-            # No response from the agent
-            return
-        resp_dict = json.loads(resp)
-        return resp_dict['message']
+        def _call():
+            # Send the encrypted password
+            transaction_id = str(uuid.uuid4())
+            args = {'id': transaction_id}
+            resp = self._make_agent_call('version', instance, '', args)
+            if resp is None:
+                # No response from the agent
+                return
+            resp_dict = json.loads(resp)
+            return resp_dict['message']
+
+        if timeout:
+            vm_ref = self._get_vm_opaque_ref(instance)
+            vm_rec = self._session.get_xenapi().VM.get_record(vm_ref)
+
+            domid = vm_rec['domid']
+
+            timeout = time.time() + timeout
+            while time.time() < timeout:
+                ret = _call()
+                if ret:
+                    return ret
+
+                if check_domid_changes:
+                    vm_rec = self._session.get_xenapi().VM.get_record(vm_ref)
+                    if vm_rec['domid'] != domid:
+                        LOG.info(_('domid changed from %(olddomid)s to '
+                                   '%(newdomid)s') % {
+                                       'olddomid': domid,
+                                        'newdomid': vm_rec['domid']})
+                        domid = vm_rec['domid']
+        else:
+            return _call()
 
     def agent_update(self, instance, url, md5sum):
         """Update agent on the VM instance."""
-- 
cgit 


From 8bd0296224b70e318e208a4570b4acaa599f62c8 Mon Sep 17 00:00:00 2001
From: Yuriy Taraday <yorik.sar@gmail.com>
Date: Fri, 17 Jun 2011 18:26:31 +0400
Subject: Made hostname independent from ec2 id. Add generation of hostnames
 based on display name.

---
 nova/api/ec2/cloud.py      |  3 +--
 nova/compute/api.py        | 24 +++++++++++++++++++++---
 nova/compute/manager.py    |  6 +++---
 nova/scheduler/driver.py   | 16 ++++++++--------
 nova/tests/test_compute.py |  2 +-
 5 files changed, 34 insertions(+), 17 deletions(-)

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index e1c65ae40..95d14ce9f 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -86,8 +86,7 @@ class CloudController(object):
         self.volume_api = volume.API()
         self.compute_api = compute.API(
                 network_api=self.network_api,
-                volume_api=self.volume_api,
-                hostname_factory=ec2utils.id_to_ec2_id)
+                volume_api=self.volume_api)
         self.setup()
 
     def __str__(self):
diff --git a/nova/compute/api.py b/nova/compute/api.py
index e2c4cf8d7..844192404 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -47,9 +47,25 @@ flags.DEFINE_integer('find_host_timeout', 30,
                      'Timeout after NN seconds when looking for a host.')
 
 
-def generate_default_hostname(instance_id):
+def generate_default_hostname(instance):
     """Default function to generate a hostname given an instance reference."""
-    return str(instance_id)
+    display_name = instance['display_name']
+    if display_name is None:
+        return 'server_%d' % (instance['id'],)
+    table = ''
+    deletions = ''
+    for i in xrange(256):
+        c = chr(i)
+        if ('a' <= c <= 'z') or ('0' <= c <= '9') or (c == '-'):
+            table += c
+        elif c == ' ':
+            table += '_'
+        elif ('A' <= c <= 'Z'):
+            table += c.lower()
+        else:
+            table += '\0'
+            deletions += c
+    return display_name.encode('latin-1', 'ignore').translate(table, deletions)
 
 
 class API(base.Base):
@@ -256,10 +272,12 @@ class API(base.Base):
                                                 security_group_id)
 
         # Set sane defaults if not specified
-        updates = dict(hostname=self.hostname_factory(instance_id))
+        updates = {}
         if (not hasattr(instance, 'display_name') or
                 instance.display_name is None):
             updates['display_name'] = "Server %s" % instance_id
+            instance['display_name'] = updates['display_name']
+        updates['hostname'] = self.hostname_factory(instance)
 
         instance = self.update(context, instance_id, **updates)
 
diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 245958de7..e84c434d2 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -933,7 +933,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         # Getting instance info
         instance_ref = self.db.instance_get(context, instance_id)
-        ec2_id = instance_ref['hostname']
+        hostname = instance_ref['hostname']
 
         # Getting fixed ips
         fixed_ip = self.db.instance_get_fixed_address(context, instance_id)
@@ -942,7 +942,7 @@ class ComputeManager(manager.SchedulerDependentManager):
 
         # If any volume is mounted, prepare here.
         if not instance_ref['volumes']:
-            LOG.info(_("%s has no volume."), ec2_id)
+            LOG.info(_("%s has no volume."), hostname)
         else:
             for v in instance_ref['volumes']:
                 self.volume_manager.setup_compute_volume(context, v['id'])
@@ -965,7 +965,7 @@ class ComputeManager(manager.SchedulerDependentManager):
                     raise
                 else:
                     LOG.warn(_("setup_compute_network() failed %(cnt)d."
-                               "Retry up to %(max_retry)d for %(ec2_id)s.")
+                               "Retry up to %(max_retry)d for %(hostname)s.")
                                % locals())
                     time.sleep(1)
 
diff --git a/nova/scheduler/driver.py b/nova/scheduler/driver.py
index 0b257c5d8..d4a30255d 100644
--- a/nova/scheduler/driver.py
+++ b/nova/scheduler/driver.py
@@ -129,8 +129,7 @@ class Scheduler(object):
         # Checking instance is running.
         if (power_state.RUNNING != instance_ref['state'] or \
            'running' != instance_ref['state_description']):
-            ec2_id = instance_ref['hostname']
-            raise exception.InstanceNotRunning(instance_id=ec2_id)
+            raise exception.InstanceNotRunning(instance_id=instance_ref['id'])
 
         # Checing volume node is running when any volumes are mounted
         # to the instance.
@@ -168,9 +167,9 @@ class Scheduler(object):
         # and dest is not same.
         src = instance_ref['host']
         if dest == src:
-            ec2_id = instance_ref['hostname']
-            raise exception.UnableToMigrateToSelf(instance_id=ec2_id,
-                                                  host=dest)
+            raise exception.UnableToMigrateToSelf(
+                    instance_id=instance_ref['id'],
+                    host=dest)
 
         # Checking dst host still has enough capacities.
         self.assert_compute_node_has_enough_resources(context,
@@ -245,7 +244,7 @@ class Scheduler(object):
         """
 
         # Getting instance information
-        ec2_id = instance_ref['hostname']
+        hostname = instance_ref['hostname']
 
         # Getting host information
         service_refs = db.service_get_all_compute_by_host(context, dest)
@@ -256,8 +255,9 @@ class Scheduler(object):
         mem_avail = mem_total - mem_used
         mem_inst = instance_ref['memory_mb']
         if mem_avail <= mem_inst:
-            reason = _("Unable to migrate %(ec2_id)s to destination: %(dest)s "
-                       "(host:%(mem_avail)s <= instance:%(mem_inst)s)")
+            reason = _("Unable to migrate %(hostname)s to destination: "
+                       "%(dest)s (host:%(mem_avail)s <= instance:"
+                       "%(mem_inst)s)")
             raise exception.MigrationError(reason=reason % locals())
 
     def mounted_on_same_shared_storage(self, context, instance_ref, dest):
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index b4ac2dbc4..8af2665bd 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -128,7 +128,7 @@ class ComputeTestCase(test.TestCase):
         instance_ref = models.Instance()
         instance_ref['id'] = 1
         instance_ref['volumes'] = [vol1, vol2]
-        instance_ref['hostname'] = 'i-00000001'
+        instance_ref['hostname'] = 'hostname-1'
         instance_ref['host'] = 'dummy'
         return instance_ref
 
-- 
cgit 


From 1acb699a6fb0ea7a7d84ba4598790d7c9d7abd14 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 20 Jun 2011 07:45:21 -0700
Subject: working commit

---
 nova/db/sqlalchemy/models.py                      |  4 ++-
 nova/scheduler/api.py                             |  6 +++--
 nova/scheduler/zone_aware_scheduler.py            | 32 ++++++++++++++++++++---
 nova/tests/api/openstack/test_zones.py            | 10 +++----
 nova/tests/scheduler/test_zone_aware_scheduler.py |  1 +
 5 files changed, 42 insertions(+), 11 deletions(-)

diff --git a/nova/db/sqlalchemy/models.py b/nova/db/sqlalchemy/models.py
index 239f6e96a..f28fb0778 100644
--- a/nova/db/sqlalchemy/models.py
+++ b/nova/db/sqlalchemy/models.py
@@ -21,7 +21,7 @@ SQLAlchemy models for nova data.
 
 from sqlalchemy.orm import relationship, backref, object_mapper
 from sqlalchemy import Column, Integer, String, schema
-from sqlalchemy import ForeignKey, DateTime, Boolean, Text
+from sqlalchemy import ForeignKey, DateTime, Boolean, Text, Float
 from sqlalchemy.exc import IntegrityError
 from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.schema import ForeignKeyConstraint
@@ -670,6 +670,8 @@ class Zone(BASE, NovaBase):
     api_url = Column(String(255))
     username = Column(String(255))
     password = Column(String(255))
+    weight_offset = Column(Float(), default=0.0)
+    weight_scale = Column(Float(), default=1.0)
 
 
 def register_models():
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index ffe59d2c1..f966528f0 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -112,7 +112,7 @@ def _process(func, zone):
 
 
 def call_zone_method(context, method_name, errors_to_ignore=None,
-                     novaclient_collection_name='zones', *args, **kwargs):
+                     novaclient_collection_name='zones', zones=None, *args, **kwargs):
     """Returns a list of (zone, call_result) objects."""
     if not isinstance(errors_to_ignore, (list, tuple)):
         # This will also handle the default None
@@ -120,7 +120,9 @@ def call_zone_method(context, method_name, errors_to_ignore=None,
 
     pool = greenpool.GreenPool()
     results = []
-    for zone in db.zone_get_all(context):
+    if zones is None:
+        zones = db.zone_get_all(context)
+    for zone in zones:
         try:
             nova = novaclient.OpenStack(zone.username, zone.password,
                     zone.api_url)
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index f04defa64..b23a1a7c1 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -48,9 +48,9 @@ class InvalidBlob(exception.NovaException):
 class ZoneAwareScheduler(driver.Scheduler):
     """Base class for creating Zone Aware Schedulers."""
 
-    def _call_zone_method(self, context, method, specs):
+    def _call_zone_method(self, context, method, specs, zones):
         """Call novaclient zone method. Broken out for testing."""
-        return api.call_zone_method(context, method, specs=specs)
+        return api.call_zone_method(context, method, specs=specs, zones=zones)
 
     def _provision_resource_locally(self, context, item, instance_id, kwargs):
         """Create the requested resource in this Zone."""
@@ -160,6 +160,30 @@ class ZoneAwareScheduler(driver.Scheduler):
         self._provision_resource_from_blob(context, item, instance_id,
                                                request_spec, kwargs)
 
+    def _adjust_child_weights(self, child_results, zones):
+        """Apply the Scale and Offset values from the Zone definition
+        to adjust the weights returned from the child zones. Alters
+        child_results in place.
+        """
+        for zone, result in child_results:
+            if not result:
+                continue
+            
+            for zone_rec in zones:
+                if zone_rec['url'] != zone:
+                    continue
+
+                try:
+                    offset = zone_rec['weight_offset']
+                    scale = zone_rec['weight_scale']
+                    raw_weight = zone['weight']
+                    cooked_weight = offset + scale * raw_weight
+                    zone['weight'] = cooked_weight
+                    zone['raw_weight'] = raw_weight
+                except Exception, e:
+                    LOG.exception(_("Bad child zone scaling values for Zone: "
+                                    "%(zone)s") % locals())
+
     def schedule_run_instance(self, context, instance_id, request_spec,
                               *args, **kwargs):
         """This method is called from nova.compute.api to provision
@@ -234,8 +258,10 @@ class ZoneAwareScheduler(driver.Scheduler):
 
         # Next, tack on the best weights from the child zones ...
         json_spec = json.dumps(request_spec)
+        all_zones = db.zone_get_all(context)
         child_results = self._call_zone_method(context, "select",
-                specs=json_spec)
+                specs=json_spec, zones=all_zones)
+        self._adjust_child_weights(child_results, all_zones)
         for child_zone, result in child_results:
             for weighting in result:
                 # Remember the child_zone so we can get back to
diff --git a/nova/tests/api/openstack/test_zones.py b/nova/tests/api/openstack/test_zones.py
index 098577e4c..6a6e13d93 100644
--- a/nova/tests/api/openstack/test_zones.py
+++ b/nova/tests/api/openstack/test_zones.py
@@ -34,7 +34,7 @@ FLAGS.verbose = True
 
 def zone_get(context, zone_id):
     return dict(id=1, api_url='http://example.com', username='bob',
-                password='xxx')
+                password='xxx', weight_scale=1.0, weight_offset=0.0)
 
 
 def zone_create(context, values):
@@ -57,9 +57,9 @@ def zone_delete(context, zone_id):
 def zone_get_all_scheduler(*args):
     return [
         dict(id=1, api_url='http://example.com', username='bob',
-                 password='xxx'),
+                 password='xxx', weight_scale=1.0, weight_offset=0.0),
         dict(id=2, api_url='http://example.org', username='alice',
-                 password='qwerty'),
+                 password='qwerty', weight_scale=1.0, weight_offset=0.0),
     ]
 
 
@@ -70,9 +70,9 @@ def zone_get_all_scheduler_empty(*args):
 def zone_get_all_db(context):
     return [
         dict(id=1, api_url='http://example.com', username='bob',
-                 password='xxx'),
+                 password='xxx', weight_scale=1.0, weight_offset=0.0),
         dict(id=2, api_url='http://example.org', username='alice',
-                 password='qwerty'),
+                 password='qwerty', weight_scale=1.0, weight_offset=0.0),
     ]
 
 
diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index 9f70b9dbc..1cbc914ef 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -16,6 +16,7 @@
 Tests For Zone Aware Scheduler.
 """
 
+from nova import db
 from nova import exception
 from nova import test
 from nova.scheduler import driver
-- 
cgit 


From 0d426ae8d0fe4e697648e58d1791e1c40b78deab Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 20 Jun 2011 16:56:59 -0700
Subject: fix lp 798361

---
 nova/compute/api.py                               | 55 ++++++++++++-----------
 nova/scheduler/zone_aware_scheduler.py            | 49 ++++++++++++--------
 nova/tests/scheduler/test_zone_aware_scheduler.py |  2 +-
 3 files changed, 59 insertions(+), 47 deletions(-)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index e6cffb6b3..cb73af94c 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -200,18 +200,7 @@ class API(base.Base):
         if ramdisk_id:
             image_service.show(context, ramdisk_id)
 
-        if security_group is None:
-            security_group = ['default']
-        if not type(security_group) is list:
-            security_group = [security_group]
-
-        security_groups = []
         self.ensure_default_security_group(context)
-        for security_group_name in security_group:
-            group = db.security_group_get_by_name(context,
-                                                  context.project_id,
-                                                  security_group_name)
-            security_groups.append(group['id'])
 
         if key_data is None and key_name:
             key_pair = db.key_pair_get(context, context.user_id, key_name)
@@ -245,15 +234,19 @@ class API(base.Base):
             'os_type': os_type,
             'vm_mode': vm_mode}
 
-        return (num_instances, base_options, security_groups)
+        return (num_instances, base_options)
 
     def create_db_entry_for_new_instance(self, context, base_options,
-             security_groups, block_device_mapping, num=1):
+             security_group, block_device_mapping, num=1):
         """Create an entry in the DB for this new instance,
-        including any related table updates (such as security
-        groups, MAC address, etc). This will called by create()
-        in the majority of situations, but all-at-once style
-        Schedulers may initiate the call."""
+        including any related table updates (such as security group,
+        MAC address, etc).
+        
+        This will called by create() in the majority of situations,
+        but create_all_at_once() style Schedulers may initiate the call.
+        If you are changing this method, be sure to update both
+        call paths.
+        """
         instance = dict(mac_address=utils.generate_mac(),
                         launch_index=num,
                         **base_options)
@@ -261,13 +254,24 @@ class API(base.Base):
         instance_id = instance['id']
 
         elevated = context.elevated()
-        if not security_groups:
-            security_groups = []
+        if security_group is None:
+            security_group = ['default']
+        if not type(security_group) is list:
+            security_group = [security_group]
+
+        security_groups = []
+        for security_group_name in security_group:
+            group = db.security_group_get_by_name(context,
+                                                  context.project_id,
+                                                  security_group_name)
+            security_groups.append(group['id'])
+
         for security_group_id in security_groups:
             self.db.instance_add_security_group(elevated,
                                                 instance_id,
                                                 security_group_id)
-
+ 
+        block_device_mapping = block_device_mapping or []
         # NOTE(yamahata)
         # tell vm driver to attach volume at boot time by updating
         # BlockDeviceMapping
@@ -339,12 +343,11 @@ class API(base.Base):
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata={},
                injected_files=None, admin_password=None, zone_blob=None,
-               reservation_id=None):
+               reservation_id=None, block_device_mapping=None):
         """Provision the instances by passing the whole request to
         the Scheduler for execution. Returns a Reservation ID
         related to the creation of all of these instances."""
-        num_instances, base_options, security_groups = \
-                    self._check_create_parameters(
+        num_instances, base_options = self._check_create_parameters(
                                context, instance_type,
                                image_href, kernel_id, ramdisk_id,
                                min_count, max_count,
@@ -379,8 +382,7 @@ class API(base.Base):
         Returns a list of instance dicts.
         """
 
-        num_instances, base_options, security_groups = \
-                    self._check_create_parameters(
+        num_instances, base_options = self._check_create_parameters(
                                context, instance_type,
                                image_href, kernel_id, ramdisk_id,
                                min_count, max_count,
@@ -390,12 +392,11 @@ class API(base.Base):
                                injected_files, admin_password, zone_blob,
                                reservation_id)
 
-        block_device_mapping = block_device_mapping or []
         instances = []
         LOG.debug(_("Going to run %s instances..."), num_instances)
         for num in range(num_instances):
             instance = self.create_db_entry_for_new_instance(context,
-                                    base_options, security_groups,
+                                    base_options, security_group,
                                     block_device_mapping, num=num)
             instances.append(instance)
             instance_id = instance['id']
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index dfee6cc2d..364d1e172 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -33,6 +33,7 @@ from nova import flags
 from nova import log as logging
 from nova import rpc
 
+from nova.compute import api as compute_api
 from nova.scheduler import api
 from nova.scheduler import driver
 
@@ -52,10 +53,21 @@ class ZoneAwareScheduler(driver.Scheduler):
         """Call novaclient zone method. Broken out for testing."""
         return api.call_zone_method(context, method, specs=specs, zones=zones)
 
-    def _provision_resource_locally(self, context, item, instance_id, kwargs):
+    def _provision_resource_locally(self, context, build_plan_item,
+                                    request_spec):
         """Create the requested resource in this Zone."""
-        host = item['hostname']
+        host = build_plan_item['hostname']
+        base_options = request_spec['instance_properties']
+
+        # TODO(sandy): I guess someone needs to add block_device_mapping
+        # support at some point? Also, OS API has no concept of security
+        # groups.
+        instance = compute_api.create_db_entry_for_new_instance(context,
+            base_options, None, [])
+
+        instance_id = instance['instance_id']
         kwargs['instance_id'] = instance_id
+
         rpc.cast(context,
                  db.queue_get_for(context, "compute", host),
                  {"method": "run_instance",
@@ -115,8 +127,8 @@ class ZoneAwareScheduler(driver.Scheduler):
         nova.servers.create(name, image_ref, flavor_id, ipgroup, meta, files,
                             child_blob, reservation_id=reservation_id)
 
-    def _provision_resource_from_blob(self, context, item, instance_id,
-                                          request_spec, kwargs):
+    def _provision_resource_from_blob(self, context, build_plan_item,
+                                      instance_id, request_spec, kwargs):
         """Create the requested resource locally or in a child zone
            based on what is stored in the zone blob info.
 
@@ -132,12 +144,12 @@ class ZoneAwareScheduler(driver.Scheduler):
            request."""
 
         host_info = None
-        if "blob" in item:
+        if "blob" in build_plan_item:
             # Request was passed in from above. Is it for us?
-            host_info = self._decrypt_blob(item['blob'])
-        elif "child_blob" in item:
+            host_info = self._decrypt_blob(build_plan_item['blob'])
+        elif "child_blob" in build_plan_item:
             # Our immediate child zone provided this info ...
-            host_info = item
+            host_info = build_plan_item
 
         if not host_info:
             raise InvalidBlob()
@@ -147,19 +159,18 @@ class ZoneAwareScheduler(driver.Scheduler):
             self._ask_child_zone_to_create_instance(context, host_info,
                                                     request_spec, kwargs)
         else:
-            self._provision_resource_locally(context, host_info,
-                                             instance_id, kwargs)
+            self._provision_resource_locally(context, host_info, request_spec)
 
-    def _provision_resource(self, context, item, instance_id, request_spec,
-                           kwargs):
+    def _provision_resource(self, context, build_plan_item, instance_id,
+                            request_spec, kwargs):
         """Create the requested resource in this Zone or a child zone."""
-        if "hostname" in item:
-            self._provision_resource_locally(context, item, instance_id,
-                            kwargs)
+        if "hostname" in build_plan_item:
+            self._provision_resource_locally(context, build_plan_item,
+                                             request_spec)
             return
 
-        self._provision_resource_from_blob(context, item, instance_id,
-                                               request_spec, kwargs)
+        self._provision_resource_from_blob(context, build_plan_item,
+                                           instance_id, request_spec, kwargs)
 
     def _adjust_child_weights(self, child_results, zones):
         """Apply the Scale and Offset values from the Zone definition
@@ -215,8 +226,8 @@ class ZoneAwareScheduler(driver.Scheduler):
                 break
 
             item = build_plan.pop(0)
-            self._provision_resource(context, item, instance_id, request_spec,
-                                    kwargs)
+            self._provision_resource(context, build_plan_item, instance_id,
+                                     request_spec, kwargs)
 
         # Returning None short-circuits the routing to Compute (since
         # we've already done it here)
diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index ef6a6a469..57fddb041 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -110,7 +110,7 @@ def fake_ask_child_zone_to_create_instance(context, zone_info,
     was_called = True
 
 
-def fake_provision_resource_locally(context, item, instance_id, kwargs):
+def fake_provision_resource_locally(context, build_plan, request_spec):
     global was_called
     was_called = True
 
-- 
cgit 


From 2d74b48984783ae09c2f29bf5c6fa0f81e6d32c2 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Mon, 20 Jun 2011 17:21:22 -0700
Subject: trunk merge

---
 nova/compute/api.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index cb73af94c..0791bab51 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -379,6 +379,9 @@ class API(base.Base):
         Scheduler drivers, but may remove the effectiveness of the
         more complicated drivers.
 
+        NOTE: If you change this method, be sure to change
+        create_all_at_once() at the same time!
+
         Returns a list of instance dicts.
         """
 
-- 
cgit 


From cd8ace7ed812010feff54829a021038f7e732ce1 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 21 Jun 2011 11:20:06 -0700
Subject: fixed local db create

---
 nova/scheduler/zone_aware_scheduler.py | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 364d1e172..c810318db 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -54,7 +54,7 @@ class ZoneAwareScheduler(driver.Scheduler):
         return api.call_zone_method(context, method, specs=specs, zones=zones)
 
     def _provision_resource_locally(self, context, build_plan_item,
-                                    request_spec):
+                                    request_spec, kwargs):
         """Create the requested resource in this Zone."""
         host = build_plan_item['hostname']
         base_options = request_spec['instance_properties']
@@ -62,10 +62,10 @@ class ZoneAwareScheduler(driver.Scheduler):
         # TODO(sandy): I guess someone needs to add block_device_mapping
         # support at some point? Also, OS API has no concept of security
         # groups.
-        instance = compute_api.create_db_entry_for_new_instance(context,
+        instance = compute_api.API().create_db_entry_for_new_instance(context,
             base_options, None, [])
 
-        instance_id = instance['instance_id']
+        instance_id = instance['id']
         kwargs['instance_id'] = instance_id
 
         rpc.cast(context,
@@ -159,14 +159,15 @@ class ZoneAwareScheduler(driver.Scheduler):
             self._ask_child_zone_to_create_instance(context, host_info,
                                                     request_spec, kwargs)
         else:
-            self._provision_resource_locally(context, host_info, request_spec)
+            self._provision_resource_locally(context, host_info, request_spec,
+                                             kwargs)
 
     def _provision_resource(self, context, build_plan_item, instance_id,
                             request_spec, kwargs):
         """Create the requested resource in this Zone or a child zone."""
         if "hostname" in build_plan_item:
             self._provision_resource_locally(context, build_plan_item,
-                                             request_spec)
+                                             request_spec, kwargs)
             return
 
         self._provision_resource_from_blob(context, build_plan_item,
@@ -225,7 +226,7 @@ class ZoneAwareScheduler(driver.Scheduler):
             if not build_plan:
                 break
 
-            item = build_plan.pop(0)
+            build_plan_item = build_plan.pop(0)
             self._provision_resource(context, build_plan_item, instance_id,
                                      request_spec, kwargs)
 
-- 
cgit 


From a1ee8e591e157a23390b1622b9c313da08ae9130 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 21 Jun 2011 12:11:16 -0700
Subject: fixed zone update

---
 nova/db/api.py            | 2 +-
 nova/db/sqlalchemy/api.py | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/db/api.py b/nova/db/api.py
index 5fd081ca8..2333e4caa 100644
--- a/nova/db/api.py
+++ b/nova/db/api.py
@@ -1253,7 +1253,7 @@ def zone_create(context, values):
 
 def zone_update(context, zone_id, values):
     """Update a child Zone entry."""
-    return IMPL.zone_update(context, values)
+    return IMPL.zone_update(context, zone_id, values)
 
 
 def zone_delete(context, zone_id):
diff --git a/nova/db/sqlalchemy/api.py b/nova/db/sqlalchemy/api.py
index a7e5125d5..64d67b17a 100644
--- a/nova/db/sqlalchemy/api.py
+++ b/nova/db/sqlalchemy/api.py
@@ -2675,7 +2675,7 @@ def zone_update(context, zone_id, values):
     if not zone:
         raise exception.ZoneNotFound(zone_id=zone_id)
     zone.update(values)
-    zone.save()
+    zone.save(session=session)
     return zone
 
 
-- 
cgit 


From d99b17895747959e332e5645aedd0a2ddc0e21da Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 21 Jun 2011 12:19:01 -0700
Subject: pep8

---
 nova/compute/api.py                               | 4 ++--
 nova/scheduler/api.py                             | 3 ++-
 nova/scheduler/zone_aware_scheduler.py            | 2 +-
 nova/tests/scheduler/test_zone_aware_scheduler.py | 2 +-
 4 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 0791bab51..1c001a8fc 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -241,7 +241,7 @@ class API(base.Base):
         """Create an entry in the DB for this new instance,
         including any related table updates (such as security group,
         MAC address, etc).
-        
+
         This will called by create() in the majority of situations,
         but create_all_at_once() style Schedulers may initiate the call.
         If you are changing this method, be sure to update both
@@ -270,7 +270,7 @@ class API(base.Base):
             self.db.instance_add_security_group(elevated,
                                                 instance_id,
                                                 security_group_id)
- 
+
         block_device_mapping = block_device_mapping or []
         # NOTE(yamahata)
         # tell vm driver to attach volume at boot time by updating
diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 733cd3dfa..f2ffcbc1f 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -114,7 +114,8 @@ def _process(func, zone):
 
 
 def call_zone_method(context, method_name, errors_to_ignore=None,
-                     novaclient_collection_name='zones', zones=None, *args, **kwargs):
+                     novaclient_collection_name='zones', zones=None,
+                     *args, **kwargs):
     """Returns a list of (zone, call_result) objects."""
     if not isinstance(errors_to_ignore, (list, tuple)):
         # This will also handle the default None
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index c810318db..dcfef6af5 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -181,7 +181,7 @@ class ZoneAwareScheduler(driver.Scheduler):
         for zone, result in child_results:
             if not result:
                 continue
-            
+
             for zone_rec in zones:
                 if zone_rec['api_url'] != zone:
                     continue
diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index 57fddb041..75c94e477 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -173,7 +173,7 @@ class ZoneAwareSchedulerTestCase(test.TestCase):
     def setUp(self):
         super(ZoneAwareSchedulerTestCase, self).setUp()
         self.stubs = stubout.StubOutForTesting()
- 
+
     def tearDown(self):
         self.stubs.UnsetAll()
         super(ZoneAwareSchedulerTestCase, self).tearDown()
-- 
cgit 


From a37ed35fe6ba3936074bacb5b32d60f05ceb229b Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Tue, 21 Jun 2011 12:19:44 -0700
Subject: pip-requires

---
 tools/pip-requires | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/pip-requires b/tools/pip-requires
index 7849dbea9..2229565c0 100644
--- a/tools/pip-requires
+++ b/tools/pip-requires
@@ -10,7 +10,7 @@ boto==1.9b
 carrot==0.10.5
 eventlet==0.9.12
 lockfile==0.8
-python-novaclient==2.5.3
+python-novaclient==2.5.5
 python-daemon==1.5.5
 python-gflags==1.3
 redis==2.0.0
-- 
cgit 


From 1f99e500a99a4d66639f04f2c723058c4d1dfc1d Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Wed, 22 Jun 2011 13:45:24 -0700
Subject: Check API request for min_count/max_count for number of instances to
 build

---
 nova/api/openstack/create_instance_helper.py |  6 ++++++
 nova/api/openstack/servers.py                |  9 +++++----
 nova/compute/api.py                          | 10 +++++++---
 3 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 436e524c1..3e055936c 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -114,6 +114,12 @@ class CreateInstanceHelper(object):
         name = name.strip()
 
         reservation_id = body['server'].get('reservation_id')
+        min_count = body['server'].get('min_count')
+        max_count = body['server'].get('max_count')
+        if min_count:
+            min_count = int(min_count)
+        if max_count:
+            max_count = int(max_count)
 
         try:
             inst_type = \
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index b82a6de19..31ec46e8e 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -111,14 +111,15 @@ class Controller(object):
         extra_values = None
         result = None
         try:
-            extra_values, result = self.helper.create_instance(
+            extra_values, instances = self.helper.create_instance(
                                     req, body, self.compute_api.create)
         except faults.Fault, f:
             return f
 
-        instances = result
-
-        (inst, ) = instances
+        # We can only return 1 instance via the API, if we happen to
+        # build more than one...  instances is a list, so we'll just
+        # use the first one..
+        inst = instances[0]
         for key in ['instance_type', 'image_ref']:
             inst[key] = extra_values[key]
 
diff --git a/nova/compute/api.py b/nova/compute/api.py
index a7ea88d51..44e11d187 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -143,7 +143,7 @@ class API(base.Base):
 
     def _check_create_parameters(self, context, instance_type,
                image_href, kernel_id=None, ramdisk_id=None,
-               min_count=1, max_count=1,
+               min_count=None, max_count=None,
                display_name='', display_description='',
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata={},
@@ -154,6 +154,10 @@ class API(base.Base):
 
         if not instance_type:
             instance_type = instance_types.get_default_instance_type()
+        if not min_count:
+            min_count = 1
+        if not max_count:
+            max_count = min_count
 
         num_instances = quota.allowed_instances(context, max_count,
                                                 instance_type)
@@ -338,7 +342,7 @@ class API(base.Base):
 
     def create_all_at_once(self, context, instance_type,
                image_href, kernel_id=None, ramdisk_id=None,
-               min_count=1, max_count=1,
+               min_count=None, max_count=None,
                display_name='', display_description='',
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata={},
@@ -368,7 +372,7 @@ class API(base.Base):
 
     def create(self, context, instance_type,
                image_href, kernel_id=None, ramdisk_id=None,
-               min_count=1, max_count=1,
+               min_count=None, max_count=None,
                display_name='', display_description='',
                key_name=None, key_data=None, security_group='default',
                availability_zone=None, user_data=None, metadata={},
-- 
cgit 


From b3c206594113ea6e9200e600490c6c991ca319d0 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 01:22:50 -0700
Subject: Add some resource checking for memory available when scheduling
 Various changes to d-sched to plan for scheduling on different topics, which
 cleans up some of the resource checking. Re-compute weights when building
 more than 1 instance, accounting for resources that would be consumed.

---
 nova/scheduler/host_filter.py          | 10 ++--
 nova/scheduler/least_cost.py           | 39 +++++++++-----
 nova/scheduler/zone_aware_scheduler.py | 94 +++++++++++++++++++++++++++-------
 3 files changed, 107 insertions(+), 36 deletions(-)

diff --git a/nova/scheduler/host_filter.py b/nova/scheduler/host_filter.py
index bd6b26608..818ae4a30 100644
--- a/nova/scheduler/host_filter.py
+++ b/nova/scheduler/host_filter.py
@@ -305,8 +305,11 @@ class HostFilterScheduler(zone_aware_scheduler.ZoneAwareScheduler):
                     'instance_type': <InstanceType dict>}
     """
 
-    def filter_hosts(self, num, request_spec):
+    def filter_hosts(self, topic, request_spec, hosts):
         """Filter the full host list (from the ZoneManager)"""
+
+        if hosts:
+            return hosts
         filter_name = request_spec.get('filter', None)
         host_filter = choose_host_filter(filter_name)
 
@@ -317,8 +320,9 @@ class HostFilterScheduler(zone_aware_scheduler.ZoneAwareScheduler):
         name, query = host_filter.instance_type_to_filter(instance_type)
         return host_filter.filter_hosts(self.zone_manager, query)
 
-    def weigh_hosts(self, num, request_spec, hosts):
+    def weigh_hosts(self, topic, request_spec, hosts):
         """Derived classes must override this method and return
         a lists of hosts in [{weight, hostname}] format.
         """
-        return [dict(weight=1, hostname=host) for host, caps in hosts]
+        return [dict(weight=1, hostname=hostname, capabilities=caps)
+                for hostname, caps in hosts]
diff --git a/nova/scheduler/least_cost.py b/nova/scheduler/least_cost.py
index 629fe2e42..72db2fd1b 100644
--- a/nova/scheduler/least_cost.py
+++ b/nova/scheduler/least_cost.py
@@ -48,25 +48,36 @@ def noop_cost_fn(host):
     return 1
 
 
-flags.DEFINE_integer('fill_first_cost_fn_weight', 1,
+flags.DEFINE_integer('compute_fill_first_cost_fn_weight', 1,
                      'How much weight to give the fill-first cost function')
 
 
-def fill_first_cost_fn(host):
+def compute_fill_first_cost_fn(host):
     """Prefer hosts that have less ram available, filter_hosts will exclude
     hosts that don't have enough ram"""
     hostname, caps = host
-    free_mem = caps['compute']['host_memory_free']
+    free_mem = caps['host_memory_free']
     return free_mem
 
 
 class LeastCostScheduler(zone_aware_scheduler.ZoneAwareScheduler):
-    def get_cost_fns(self):
+    def __init__(self, *args, **kwargs):
+        self.cost_fns_cache = {}
+        super(LeastCoastScheduler, self).__init__(*args, **kwargs)
+
+    def get_cost_fns(self, topic):
         """Returns a list of tuples containing weights and cost functions to
         use for weighing hosts
         """
+
+        if topic in self.cost_fns_cache:
+            return self.cost_fns_cache[topic]
+
         cost_fns = []
         for cost_fn_str in FLAGS.least_cost_scheduler_cost_functions:
+            if not cost_fn_str.startswith('%s_' % topic) and \
+                    not cost_fn_str.startswith('noop'):
+                continue
 
             try:
                 # NOTE(sirp): import_class is somewhat misnamed since it can
@@ -84,23 +95,23 @@ class LeastCostScheduler(zone_aware_scheduler.ZoneAwareScheduler):
 
             cost_fns.append((weight, cost_fn))
 
+        self.cost_fns_cache[topic] = cost_fns
         return cost_fns
 
-    def weigh_hosts(self, num, request_spec, hosts):
+    def weigh_hosts(self, topic, request_spec, hosts):
         """Returns a list of dictionaries of form:
-            [ {weight: weight, hostname: hostname} ]"""
-
-        # FIXME(sirp): weigh_hosts should handle more than just instances
-        hostnames = [hostname for hostname, caps in hosts]
+           [ {weight: weight, hostname: hostname, capabilities: capabs} ]
+        """
 
-        cost_fns = self.get_cost_fns()
+        cost_fns = self.get_cost_fns(topic)
         costs = weighted_sum(domain=hosts, weighted_fns=cost_fns)
 
         weighted = []
         weight_log = []
-        for cost, hostname in zip(costs, hostnames):
+        for cost, (hostname, caps) in zip(costs, hosts):
             weight_log.append("%s: %s" % (hostname, "%.2f" % cost))
-            weight_dict = dict(weight=cost, hostname=hostname)
+            weight_dict = dict(weight=cost, hostname=hostname,
+                    capabilities=caps)
             weighted.append(weight_dict)
 
         LOG.debug(_("Weighted Costs => %s") % weight_log)
@@ -127,7 +138,8 @@ def weighted_sum(domain, weighted_fns, normalize=True):
     weighted_fns - list of weights and functions like:
         [(weight, objective-functions)]
 
-    Returns an unsorted of scores. To pair with hosts do: zip(scores, hosts)
+    Returns an unsorted list of scores. To pair with hosts do:
+        zip(scores, hosts)
     """
     # Table of form:
     #   { domain1: [score1, score2, ..., scoreM]
@@ -150,7 +162,6 @@ def weighted_sum(domain, weighted_fns, normalize=True):
     domain_scores = []
     for idx in sorted(score_table):
         elem_score = sum(score_table[idx])
-        elem = domain[idx]
         domain_scores.append(elem_score)
 
     return domain_scores
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index e7bff2faa..d4d3d0414 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -224,18 +224,34 @@ class ZoneAwareScheduler(driver.Scheduler):
             raise NotImplemented(_("Zone Aware Scheduler only understands "
                                    "Compute nodes (for now)"))
 
-        #TODO(sandy): how to infer this from OS API params?
-        num_instances = 1
-
-        # Filter local hosts based on requirements ...
-        host_list = self.filter_hosts(num_instances, request_spec)
+        num_instances = request_spec['num_instances']
+        instance_type = request_spec['instance_type']
 
-        # TODO(sirp): weigh_hosts should also be a function of 'topic' or
-        # resources, so that we can apply different objective functions to it
+        weighted = []
+        host_list = None
+
+        for i in xrange(num_instances):
+            # Filter local hosts based on requirements ...
+            #
+            # The first pass through here will pass 'None' as the
+            # host_list.. which tells the filter to build the full
+            # list of hosts.
+            # On a 2nd pass, the filter can modify the host_list with
+            # any updates it needs to make based on resources that
+            # may have been consumed from a previous build..
+            host_list = self.filter_hosts(topic, request_spec, host_list)
+            if not host_list:
+                break
 
-        # then weigh the selected hosts.
-        # weighted = [{weight=weight, name=hostname}, ...]
-        weighted = self.weigh_hosts(num_instances, request_spec, host_list)
+            # then weigh the selected hosts.
+            # weighted = [{weight=weight, hostname=hostname,
+            #              capabilities=capabs}, ...]
+            weights = self.weigh_hosts(topic, request_spec, host_list)
+            weights.sort(key=operator.itemgetter('weight'))
+            best_weight = weights[0]
+            weighted.append(best_weight)
+            self.consume_resources(best_weight['capabilities'],
+                    instance_type)
 
         # Next, tack on the best weights from the child zones ...
         json_spec = json.dumps(request_spec)
@@ -254,18 +270,58 @@ class ZoneAwareScheduler(driver.Scheduler):
         weighted.sort(key=operator.itemgetter('weight'))
         return weighted
 
-    def filter_hosts(self, num, request_spec):
-        """Derived classes must override this method and return
-           a list of hosts in [(hostname, capability_dict)] format.
+    def compute_filter(self, hostname, capabilities, request_spec):
+        """Return whether or not we can schedule to this compute node.
+        Derived classes should override this and return True if the host
+        is acceptable for scheduling.
         """
-        # NOTE(sirp): The default logic is the equivalent to AllHostsFilter
-        service_states = self.zone_manager.service_states
-        return [(host, services)
-                for host, services in service_states.iteritems()]
+        instance_type = request_spec['instance_type']
+        reqested_mem = instance_type['memory_mb']
+        return capabilities['host_memory_free'] >= requested_mem
+
+    def filter_hosts(self, topic, request_spec, host_list=None):
+        """Return a list of hosts which are acceptable for scheduling.
+        Return value should be a list of (hostname, capability_dict)s.
+        Derived classes may override this, but may find the
+        '<topic>_filter' function more appropriate.
+        """
+
+        def _default_filter(self, hostname, capabilities, request_spec):
+            """Default filter function if there's no <topic>_filter"""
+            # NOTE(sirp): The default logic is the equivalent to
+            # AllHostsFilter
+            return True
+
+        filter_func = getattr(self, '%s_filter' % topic, _default_filter)
 
-    def weigh_hosts(self, num, request_spec, hosts):
+        filtered_hosts = []
+        if host_list is None:
+            host_list = self.zone_manager.service_states.iteritems()
+        for host, services in host_list:
+            if topic not in services:
+                continue
+            if filter_func(host, services['topic'], request_spec):
+                filtered_hosts.append((host, services['topic']))
+
+    def weigh_hosts(self, topic, request_spec, hosts):
         """Derived classes may override this to provide more sophisticated
         scheduling objectives
         """
         # NOTE(sirp): The default logic is the same as the NoopCostFunction
-        return [dict(weight=1, hostname=host) for host, caps in hosts]
+        return [dict(weight=1, hostname=hostname, capabilities=capabilities)
+                for hostname, capabilities in hosts]
+
+    def compute_consume(self, capabilities, instance_type):
+        """Consume compute resources for selected host"""
+
+        requested_mem = max(instance_type['memory_mb'], 0)
+        capabilities['host_memory_free'] -= requested_mem
+
+    def consume_resources(self, topic, capabilities, instance_type):
+        """Consume resources for a specific host.  'host' is a tuple
+        of the hostname and the services"""
+
+        consume_func = getattr(self, '%s_consume' % topic, None)
+        if not consume_func:
+            return
+        consume_func(capabilities, instance_type)
-- 
cgit 


From b9a861d72f1a98510dd4b68e547b434388ab9a64 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 05:20:50 -0700
Subject: add support for compute_api.get_all() recursing zones for more than
 just reservation_id

---
 nova/api/openstack/servers.py | 13 +++++++--
 nova/compute/api.py           | 66 ++++++++++++++++++++++---------------------
 2 files changed, 45 insertions(+), 34 deletions(-)

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index b82a6de19..8c93ce230 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -76,10 +76,19 @@ class Controller(object):
 
         builder - the response model builder
         """
-        reservation_id = req.str_GET.get('reservation_id')
+        query_str = req.str_GET()
+        reservation_id = query_str.get('reservation_id')
+        project_id = query_str.get('project_id')
+        fixed_ip = query_str.get('fixed_ip')
+        recurse_zones = query_str.get('recurse_zones')
+        if recurse_zones is not None:
+            recurse_zones = True
         instance_list = self.compute_api.get_all(
                                             req.environ['nova.context'],
-                                            reservation_id=reservation_id)
+                                            reservation_id=reservation_id,
+                                            project_id=project_id,
+                                            fixed_ip=fixed_ip,
+                                            recurse_zones=recurse_zones)
         limited_list = self._limit_items(instance_list, req)
         builder = self._get_view_builder(req)
         servers = [builder.build(inst, is_detail)['server']
diff --git a/nova/compute/api.py b/nova/compute/api.py
index a7ea88d51..9db83d65f 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -603,50 +603,52 @@ class API(base.Base):
         """
         return self.get(context, instance_id)
 
-    def get_all_across_zones(self, context, reservation_id):
-        """Get all instances with this reservation_id, across
-        all available Zones (if any).
-        """
-        context = context.elevated()
-        instances = self.db.instance_get_all_by_reservation(
-                                    context, reservation_id)
-
-        children = scheduler_api.call_zone_method(context, "list",
-                                novaclient_collection_name="servers",
-                                reservation_id=reservation_id)
-
-        for zone, servers in children:
-            for server in servers:
-                # Results are ready to send to user. No need to scrub.
-                server._info['_is_precooked'] = True
-                instances.append(server._info)
-        return instances
-
     def get_all(self, context, project_id=None, reservation_id=None,
-                fixed_ip=None):
+                fixed_ip=None, recurse_zones=False):
         """Get all instances filtered by one of the given parameters.
 
         If there is no filter and the context is an admin, it will retreive
         all instances in the system.
         """
-        if reservation_id is not None:
-            return self.get_all_across_zones(context, reservation_id)
+        admin_context = context.elevated()
 
-        if fixed_ip is not None:
-            return self.db.fixed_ip_get_instance(context, fixed_ip)
-
-        if project_id or not context.is_admin:
+        if reservation_id is not None:
+            recurse_zones = True
+            instances = self.db.instance_get_all_by_reservation(
+                                    context, reservation_id)
+        elif fixed_ip is not None:
+            instances = self.db.fixed_ip_get_instance(context, fixed_ip)
+        elif project_id or not context.is_admin:
             if not context.project:
-                return self.db.instance_get_all_by_user(
+                instances = self.db.instance_get_all_by_user(
                     context, context.user_id)
+            else:
+                if project_id is None:
+                    project_id = context.project_id
+                instances = self.db.instance_get_all_by_project(
+                    context, project_id)
+        else:
+            instances = self.db.instance_get_all(context)
+
+        if not isinstance(instances, list):
+            instances = [instances]
 
-            if project_id is None:
-                project_id = context.project_id
+        if not recurse_zones:
+            return instances
 
-            return self.db.instance_get_all_by_project(
-                context, project_id)
+        children = scheduler_api.call_zone_method(admin_context, "list",
+                                novaclient_collection_name="servers",
+                                reservation_id=reservation_id,
+                                project_id=project_id,
+                                fixed_ip=fixed_ip
+                                recurse_zones=True)
 
-        return self.db.instance_get_all(context)
+        for zone, servers in children:
+            for server in servers:
+                # Results are ready to send to user. No need to scrub.
+                server._info['_is_precooked'] = True
+                instances.append(server._info)
+        return instances
 
     def _cast_compute_message(self, method, context, instance_id, host=None,
                               params=None):
-- 
cgit 


From 1aa7e746d5918f2a664da1937183b66fe31f6bd4 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 05:35:04 -0700
Subject: typo

---
 nova/compute/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 9db83d65f..1b3997db7 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -640,7 +640,7 @@ class API(base.Base):
                                 novaclient_collection_name="servers",
                                 reservation_id=reservation_id,
                                 project_id=project_id,
-                                fixed_ip=fixed_ip
+                                fixed_ip=fixed_ip,
                                 recurse_zones=True)
 
         for zone, servers in children:
-- 
cgit 


From 07404e266a4a6b690c62624a9a5e47d60cab7d5b Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 06:33:25 -0700
Subject: fixes for recurse_zones and None instances with compute's get_all

---
 nova/api/openstack/servers.py | 3 +--
 nova/compute/api.py           | 6 ++++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 8c93ce230..9e861359a 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -81,8 +81,7 @@ class Controller(object):
         project_id = query_str.get('project_id')
         fixed_ip = query_str.get('fixed_ip')
         recurse_zones = query_str.get('recurse_zones')
-        if recurse_zones is not None:
-            recurse_zones = True
+        recurse_zones = recurse_zones and True or False
         instance_list = self.compute_api.get_all(
                                             req.environ['nova.context'],
                                             reservation_id=reservation_id,
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 1b3997db7..e31edf7bb 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -610,7 +610,6 @@ class API(base.Base):
         If there is no filter and the context is an admin, it will retreive
         all instances in the system.
         """
-        admin_context = context.elevated()
 
         if reservation_id is not None:
             recurse_zones = True
@@ -630,12 +629,15 @@ class API(base.Base):
         else:
             instances = self.db.instance_get_all(context)
 
-        if not isinstance(instances, list):
+        if instances is None:
+            instances = []
+        elif not isinstance(instances, list):
             instances = [instances]
 
         if not recurse_zones:
             return instances
 
+        admin_context = context.elevated()
         children = scheduler_api.call_zone_method(admin_context, "list",
                                 novaclient_collection_name="servers",
                                 reservation_id=reservation_id,
-- 
cgit 


From 575ea1963bef8c76597ef3a6541c5d0c13635b17 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 06:52:19 -0700
Subject: minor fixups

---
 nova/scheduler/host_filter.py          | 4 +---
 nova/scheduler/zone_aware_scheduler.py | 1 +
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/nova/scheduler/host_filter.py b/nova/scheduler/host_filter.py
index 818ae4a30..b336665be 100644
--- a/nova/scheduler/host_filter.py
+++ b/nova/scheduler/host_filter.py
@@ -305,11 +305,9 @@ class HostFilterScheduler(zone_aware_scheduler.ZoneAwareScheduler):
                     'instance_type': <InstanceType dict>}
     """
 
-    def filter_hosts(self, topic, request_spec, hosts):
+    def filter_hosts(self, topic, request_spec, hosts=None):
         """Filter the full host list (from the ZoneManager)"""
 
-        if hosts:
-            return hosts
         filter_name = request_spec.get('filter', None)
         host_filter = choose_host_filter(filter_name)
 
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index d4d3d0414..70cb83e8a 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -302,6 +302,7 @@ class ZoneAwareScheduler(driver.Scheduler):
                 continue
             if filter_func(host, services['topic'], request_spec):
                 filtered_hosts.append((host, services['topic']))
+        return filtered_hosts
 
     def weigh_hosts(self, topic, request_spec, hosts):
         """Derived classes may override this to provide more sophisticated
-- 
cgit 


From e241f5301621e66360bb884193884f9f98bc8832 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 07:02:49 -0700
Subject: str_GET is a property

---
 nova/api/openstack/servers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 9e861359a..d499066be 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -76,7 +76,7 @@ class Controller(object):
 
         builder - the response model builder
         """
-        query_str = req.str_GET()
+        query_str = req.str_GET
         reservation_id = query_str.get('reservation_id')
         project_id = query_str.get('project_id')
         fixed_ip = query_str.get('fixed_ip')
-- 
cgit 


From b637dee5a5c48f86f6b8b12b3b374344b4ffc5b7 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 07:15:20 -0700
Subject: handle errors for listing an instance by IP address

---
 nova/compute/api.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 02963068a..31333ad18 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -620,7 +620,12 @@ class API(base.Base):
             instances = self.db.instance_get_all_by_reservation(
                                     context, reservation_id)
         elif fixed_ip is not None:
-            instances = self.db.fixed_ip_get_instance(context, fixed_ip)
+            try:
+                instances = self.db.fixed_ip_get_instance(context, fixed_ip)
+            except exception.FloatingIpNotFound, e:
+                if not recurse_zones:
+                    raise
+                instances = None
         elif project_id or not context.is_admin:
             if not context.project:
                 instances = self.db.instance_get_all_by_user(
-- 
cgit 


From 9044733fb0aff698875080caf1ffd9e44470ec0e Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 23 Jun 2011 10:53:09 -0400
Subject: adding metadata container to /images/detail and /images/<id> calls

---
 nova/api/openstack/views/images.py      |  3 +++
 nova/tests/api/openstack/test_images.py | 45 +++++++++++++++++++++++++--------
 2 files changed, 38 insertions(+), 10 deletions(-)

diff --git a/nova/api/openstack/views/images.py b/nova/api/openstack/views/images.py
index 2773c9c13..e7472b5cd 100644
--- a/nova/api/openstack/views/images.py
+++ b/nova/api/openstack/views/images.py
@@ -109,6 +109,9 @@ class ViewBuilderV11(ViewBuilder):
         image = ViewBuilder.build(self, image_obj, detail)
         href = self.generate_href(image_obj["id"])
 
+        if detail:
+            image["metadata"] = image_obj.get("properties", {})
+
         image["links"] = [{
             "rel": "self",
             "href": href,
diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index e4204809f..6ec0f8712 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -393,20 +393,25 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         self.assertEqual(expected_image, actual_image)
 
     def test_get_image_v1_1(self):
-        request = webob.Request.blank('/v1.1/images/123')
+        request = webob.Request.blank('/v1.1/images/124')
         response = request.get_response(fakes.wsgi_app())
 
         actual_image = json.loads(response.body)
 
-        href = "http://localhost/v1.1/images/123"
+        href = "http://localhost/v1.1/images/124"
 
         expected_image = {
             "image": {
-                "id": 123,
-                "name": "public image",
+                "id": 124,
+                "name": "queued backup",
+                "serverRef": "http://localhost/v1.1/servers/42",
                 "updated": self.NOW_API_FORMAT,
                 "created": self.NOW_API_FORMAT,
-                "status": "ACTIVE",
+                "status": "QUEUED",
+                "metadata": {
+                    "instance_id": "42",
+                    "user_id": "1",
+                },
                 "links": [{
                     "rel": "self",
                     "href": href,
@@ -465,20 +470,21 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         self.assertEqual(expected_image.toxml(), actual_image.toxml())
 
     def test_get_image_v1_1_xml(self):
-        request = webob.Request.blank('/v1.1/images/123')
+        request = webob.Request.blank('/v1.1/images/124')
         request.accept = "application/xml"
         response = request.get_response(fakes.wsgi_app())
 
         actual_image = minidom.parseString(response.body.replace("  ", ""))
 
-        expected_href = "http://localhost/v1.1/images/123"
+        expected_href = "http://localhost/v1.1/images/124"
         expected_now = self.NOW_API_FORMAT
         expected_image = minidom.parseString("""
-        <image id="123"
-                name="public image"
+        <image id="124"
+                name="queued backup"
+                serverRef="http://localhost/v1.1/servers/42"
                 updated="%(expected_now)s"
                 created="%(expected_now)s"
-                status="ACTIVE"
+                status="QUEUED"
                 xmlns="http://docs.openstack.org/compute/api/v1.1">
             <links>
                 <link href="%(expected_href)s" rel="self"/>
@@ -487,6 +493,14 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
                 <link href="%(expected_href)s" rel="bookmark"
                     type="application/xml" />
             </links>
+            <metadata>
+                <instance_id>
+                    42
+                </instance_id>
+                <user_id>
+                    1
+                </user_id>
+            </metadata>
         </image>
         """.replace("  ", "") % (locals()))
 
@@ -668,6 +682,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         expected = [{
             'id': 123,
             'name': 'public image',
+            'metadata': {},
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
             'status': 'ACTIVE',
@@ -689,6 +704,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {
             'id': 124,
             'name': 'queued backup',
+            'metadata': {u'instance_id': u'42', u'user_id': u'1'},
             'serverRef': "http://localhost/v1.1/servers/42",
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
@@ -711,6 +727,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {
             'id': 125,
             'name': 'saving backup',
+            'metadata': {u'instance_id': u'42', u'user_id': u'1'},
             'serverRef': "http://localhost/v1.1/servers/42",
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
@@ -734,6 +751,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {
             'id': 126,
             'name': 'active backup',
+            'metadata': {u'instance_id': u'42', u'user_id': u'1'},
             'serverRef': "http://localhost/v1.1/servers/42",
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
@@ -756,6 +774,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {
             'id': 127,
             'name': 'killed backup',
+            'metadata': {u'instance_id': u'42', u'user_id': u'1'},
             'serverRef': "http://localhost/v1.1/servers/42",
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
@@ -778,6 +797,7 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
         {
             'id': 129,
             'name': None,
+            'metadata': {},
             'updated': self.NOW_API_FORMAT,
             'created': self.NOW_API_FORMAT,
             'status': 'ACTIVE',
@@ -1030,6 +1050,11 @@ class ImageControllerWithGlanceServiceTest(test.TestCase):
                     <link href="%(expected_href)s" rel="bookmark"
                         type="application/xml" />
                 </links>
+                <metadata>
+                    <instance_id>
+                        123
+                    </instance_id>
+                </metadata>
             </image>
         """.replace("  ", "") % (locals()))
 
-- 
cgit 


From b186f7ae1515b8296f5fdb7f86b67c07973bb463 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 23 Jun 2011 12:41:57 -0400
Subject: fixing 500 on None metadata value

---
 nova/api/openstack/image_metadata.py            |  2 +-
 nova/tests/api/openstack/test_image_metadata.py | 20 ++++++++++++++++++++
 2 files changed, 21 insertions(+), 1 deletion(-)

diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index 90cbfe04c..639e4320d 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -111,7 +111,7 @@ class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
     def _meta_item_to_xml(self, doc, key, value):
         node = doc.createElement('meta')
         node.setAttribute('key', key)
-        text = doc.createTextNode(value)
+        text = doc.createTextNode(str(value))
         node.appendChild(text)
         return node
 
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 9495eadec..52905056d 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -130,6 +130,26 @@ class ImageMetaDataTest(unittest.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
+    def test_index_xml_null_value(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'metadata': {
+                'three': None,
+            },
+        }
+        output = serializer.index(fixture)
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <meta key="three">
+                    None
+                </meta>
+            </metadata>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
     def test_show(self):
         req = webob.Request.blank('/v1.1/images/1/meta/key1')
         req.environ['api.version'] = '1.1'
-- 
cgit 


From 16b858d804c3df473617c776a7cb74ea284b8f3a Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 09:43:27 -0700
Subject: an int() was missed being removed from UUID changes when zone
 rerouting kicks in

---
 nova/scheduler/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 1bb047e2e..0aed75680 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -169,7 +169,7 @@ def _issue_novaclient_command(nova, zone, collection, method_name, item_id):
     result = None
     try:
         try:
-            result = manager.get(int(item_id))
+            result = manager.get(item_id)
         except ValueError, e:
             result = manager.find(name=item_id)
     except novaclient.NotFound:
-- 
cgit 


From 1b5cde761bd699f6fec207f4b1b41d8c63ea1ec7 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Thu, 23 Jun 2011 15:48:49 -0400
Subject: fixing 500 error on v1.0 images xml

---
 nova/api/openstack/images.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/api/openstack/images.py b/nova/api/openstack/images.py
index 31b2e1c37..ed1811779 100644
--- a/nova/api/openstack/images.py
+++ b/nova/api/openstack/images.py
@@ -262,7 +262,7 @@ def create_resource(version='1.0'):
     }
 
     xml_serializer = {
-        '1.0': wsgi.XMLDictSerializer(wsgi.XMLNS_V10, metadata),
+        '1.0': wsgi.XMLDictSerializer(metadata, wsgi.XMLNS_V10),
         '1.1': ImageXMLSerializer(),
     }[version]
 
-- 
cgit 


From 65ec0ce423e211215d82001778560dcaa92866a1 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 21:59:54 -0700
Subject: missed passing an argument to consume_resources

---
 nova/scheduler/zone_aware_scheduler.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 70cb83e8a..073bdd3bd 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -250,7 +250,7 @@ class ZoneAwareScheduler(driver.Scheduler):
             weights.sort(key=operator.itemgetter('weight'))
             best_weight = weights[0]
             weighted.append(best_weight)
-            self.consume_resources(best_weight['capabilities'],
+            self.consume_resources(topic, best_weight['capabilities'],
                     instance_type)
 
         # Next, tack on the best weights from the child zones ...
-- 
cgit 


From 2c303bcc8f47aaa5cdeee0ee91e3f4b434176f15 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 22:45:58 -0700
Subject: missed passing in min/max_count into the create/create_all_at_once
 calls

---
 nova/api/openstack/create_instance_helper.py | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 3e055936c..4c6cc0f83 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -120,6 +120,8 @@ class CreateInstanceHelper(object):
             min_count = int(min_count)
         if max_count:
             max_count = int(max_count)
+        if min_count > max_count:
+            min_count = max_count
 
         try:
             inst_type = \
@@ -143,7 +145,9 @@ class CreateInstanceHelper(object):
                                   injected_files=injected_files,
                                   admin_password=password,
                                   zone_blob=zone_blob,
-                                  reservation_id=reservation_id))
+                                  reservation_id=reservation_id,
+                                  min_count=min_count,
+                                  max_count=max_count))
         except quota.QuotaError as error:
             self._handle_quota_error(error)
         except exception.ImageNotFound as error:
-- 
cgit 


From 72d478b3ac12033928a53d51aa9c0ffbdfc9907f Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 22:48:44 -0700
Subject: debug logging of number of instances to build in scheduler

---
 nova/scheduler/zone_aware_scheduler.py | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 073bdd3bd..a747526d1 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -180,18 +180,21 @@ class ZoneAwareScheduler(driver.Scheduler):
                                     request_spec, kwargs)
             return None
 
+        num_instances = request_spec['num_instances']
+        LOG.debug(_("Attemping to build %d instance%s") %
+            (num_instances, "" if num_instances == 1 else "s"))
+
         # Create build plan and provision ...
         build_plan = self.select(context, request_spec)
         if not build_plan:
             raise driver.NoValidHost(_('No hosts were available'))
 
-        for num in xrange(request_spec['num_instances']):
+        for num in xrange(num_instances):
             if not build_plan:
                 break
-
             item = build_plan.pop(0)
-            self._provision_resource(context, item, instance_id, request_spec,
-                                    kwargs)
+            self._provision_resource(context, item, instance_id,
+                    request_spec, kwargs)
 
         # Returning None short-circuits the routing to Compute (since
         # we've already done it here)
-- 
cgit 


From 9ededda0bdc990a4e6823f5076aa8b9e2de43c7e Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 22:55:45 -0700
Subject: typo in least cost scheduler

---
 nova/scheduler/least_cost.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/scheduler/least_cost.py b/nova/scheduler/least_cost.py
index 72db2fd1b..9376631ef 100644
--- a/nova/scheduler/least_cost.py
+++ b/nova/scheduler/least_cost.py
@@ -63,7 +63,7 @@ def compute_fill_first_cost_fn(host):
 class LeastCostScheduler(zone_aware_scheduler.ZoneAwareScheduler):
     def __init__(self, *args, **kwargs):
         self.cost_fns_cache = {}
-        super(LeastCoastScheduler, self).__init__(*args, **kwargs)
+        super(LeastCostScheduler, self).__init__(*args, **kwargs)
 
     def get_cost_fns(self, topic):
         """Returns a list of tuples containing weights and cost functions to
-- 
cgit 


From 56bbeaa4881979af281ded41b897ad87697f331a Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 23:00:15 -0700
Subject: more typos

---
 nova/scheduler/zone_aware_scheduler.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index a747526d1..8f218c159 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -303,8 +303,8 @@ class ZoneAwareScheduler(driver.Scheduler):
         for host, services in host_list:
             if topic not in services:
                 continue
-            if filter_func(host, services['topic'], request_spec):
-                filtered_hosts.append((host, services['topic']))
+            if filter_func(host, services[topic], request_spec):
+                filtered_hosts.append((host, services[topic]))
         return filtered_hosts
 
     def weigh_hosts(self, topic, request_spec, hosts):
-- 
cgit 


From 108314eac2f3c91be68c525902ce31e3abab4ecd Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 23:05:12 -0700
Subject: requested_mem typo

---
 nova/scheduler/zone_aware_scheduler.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 8f218c159..769b2dd0f 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -279,7 +279,7 @@ class ZoneAwareScheduler(driver.Scheduler):
         is acceptable for scheduling.
         """
         instance_type = request_spec['instance_type']
-        reqested_mem = instance_type['memory_mb']
+        requested_mem = instance_type['memory_mb']
         return capabilities['host_memory_free'] >= requested_mem
 
     def filter_hosts(self, topic, request_spec, host_list=None):
-- 
cgit 


From 4307daa9848060aad4b714394f314e5b6e823208 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Thu, 23 Jun 2011 23:38:32 -0700
Subject: LeastCostScheduler wasn't checking for topic cost functions
 correctly. Added support so that --least_cost_scheduler_cost_functions only
 needs to have method names specified, instead of the full blown version with
 module and class name.  Still works the old way, too.

---
 nova/scheduler/least_cost.py | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/nova/scheduler/least_cost.py b/nova/scheduler/least_cost.py
index 9376631ef..6f5eb66fd 100644
--- a/nova/scheduler/least_cost.py
+++ b/nova/scheduler/least_cost.py
@@ -75,8 +75,15 @@ class LeastCostScheduler(zone_aware_scheduler.ZoneAwareScheduler):
 
         cost_fns = []
         for cost_fn_str in FLAGS.least_cost_scheduler_cost_functions:
-            if not cost_fn_str.startswith('%s_' % topic) and \
-                    not cost_fn_str.startswith('noop'):
+            if '.' in cost_fn_str:
+                short_name = cost_fn_str.split('.')[-1]
+            else:
+                short_name = cost_fn_str
+                cost_fn_str = "%s.%s.%s" % (
+                        __name__, self.__class__.__name__, short_name)
+
+            if not (short_name.startswith('%s_' % topic) or
+                    short_name.startswith('noop')):
                 continue
 
             try:
-- 
cgit 


From 95b9a83473dad5a2c60e146c0428b2c16d234232 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Fri, 24 Jun 2011 00:26:55 -0700
Subject: on 2nd run through filter_hosts, we've already accounted for the
 topic memory needs converted to Bytes from MB

---
 nova/scheduler/zone_aware_scheduler.py | 22 +++++++++++++++-------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 769b2dd0f..e6383b20b 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -244,6 +244,8 @@ class ZoneAwareScheduler(driver.Scheduler):
             # may have been consumed from a previous build..
             host_list = self.filter_hosts(topic, request_spec, host_list)
             if not host_list:
+                LOG.warn(_("Ran out of available hosts after weighing "
+                        "%d of %d instances") % (i, num_instances))
                 break
 
             # then weigh the selected hosts.
@@ -279,7 +281,7 @@ class ZoneAwareScheduler(driver.Scheduler):
         is acceptable for scheduling.
         """
         instance_type = request_spec['instance_type']
-        requested_mem = instance_type['memory_mb']
+        requested_mem = instance_type['memory_mb'] * 1024 * 1024
         return capabilities['host_memory_free'] >= requested_mem
 
     def filter_hosts(self, topic, request_spec, host_list=None):
@@ -297,14 +299,20 @@ class ZoneAwareScheduler(driver.Scheduler):
 
         filter_func = getattr(self, '%s_filter' % topic, _default_filter)
 
-        filtered_hosts = []
         if host_list is None:
+            first_run = True
             host_list = self.zone_manager.service_states.iteritems()
+        else:
+            first_run = False
+
+        filtered_hosts = []
         for host, services in host_list:
-            if topic not in services:
-                continue
-            if filter_func(host, services[topic], request_spec):
-                filtered_hosts.append((host, services[topic]))
+            if first_run:
+                if topic not in services:
+                    continue
+                services = services['topic']
+            if filter_func(host, services, request_spec):
+                filtered_hosts.append((host, services))
         return filtered_hosts
 
     def weigh_hosts(self, topic, request_spec, hosts):
@@ -318,7 +326,7 @@ class ZoneAwareScheduler(driver.Scheduler):
     def compute_consume(self, capabilities, instance_type):
         """Consume compute resources for selected host"""
 
-        requested_mem = max(instance_type['memory_mb'], 0)
+        requested_mem = max(instance_type['memory_mb'], 0) * 1024 * 1024
         capabilities['host_memory_free'] -= requested_mem
 
     def consume_resources(self, topic, capabilities, instance_type):
-- 
cgit 


From d97120f40b68870bebec0c41b13784a6cd1ddd92 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Fri, 24 Jun 2011 00:30:58 -0700
Subject: same typo i made before!

---
 nova/scheduler/zone_aware_scheduler.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index e6383b20b..e24c2256f 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -310,7 +310,7 @@ class ZoneAwareScheduler(driver.Scheduler):
             if first_run:
                 if topic not in services:
                     continue
-                services = services['topic']
+                services = services[topic]
             if filter_func(host, services, request_spec):
                 filtered_hosts.append((host, services))
         return filtered_hosts
-- 
cgit 


From 9bd5afb3246abecaa25beaabac12f28da35887e5 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Sun, 26 Jun 2011 17:32:19 -0400
Subject: adding xml serialization test of zero images

---
 nova/tests/api/openstack/test_images.py | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/nova/tests/api/openstack/test_images.py b/nova/tests/api/openstack/test_images.py
index cf299a4be..01e2aab3f 100644
--- a/nova/tests/api/openstack/test_images.py
+++ b/nova/tests/api/openstack/test_images.py
@@ -1166,6 +1166,24 @@ class ImageXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
+    def test_index_zero_images(self):
+        serializer = images.ImageXMLSerializer()
+
+        fixtures = {
+            'images': [],
+        }
+
+        output = serializer.serialize(fixtures, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected_serverRef = self.SERVER_HREF
+        expected_now = self.TIMESTAMP
+        expected = minidom.parseString("""
+        <images xmlns="http://docs.openstack.org/compute/api/v1.1" />
+        """.replace("  ", "") % (locals()))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
     def test_detail(self):
         serializer = images.ImageXMLSerializer()
 
-- 
cgit 


From c5fe1839feb2d837a03a916a9af564d941d0c320 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Mon, 27 Jun 2011 11:26:37 -0400
Subject: extracting images metadata xml serialization tests into specific
 class; adding unicode image metadata value test

---
 nova/tests/api/openstack/test_image_metadata.py | 242 +++++++++++++-----------
 1 file changed, 133 insertions(+), 109 deletions(-)

diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index c8a4a8341..9544389dd 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -24,6 +24,7 @@ import xml.dom.minidom as minidom
 
 from nova import flags
 from nova.api import openstack
+from nova import test
 from nova.tests.api.openstack import fakes
 import nova.wsgi
 
@@ -31,7 +32,7 @@ import nova.wsgi
 FLAGS = flags.FLAGS
 
 
-class ImageMetaDataTest(unittest.TestCase):
+class ImageMetaDataTest(test.TestCase):
 
     IMAGE_FIXTURES = [
         {'status': 'active',
@@ -112,50 +113,6 @@ class ImageMetaDataTest(unittest.TestCase):
         for (key, value) in res_dict['metadata'].items():
             self.assertEqual(value, res_dict['metadata'][key])
 
-    def test_index_xml(self):
-        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
-        fixture = {
-            'metadata': {
-                'one': 'two',
-                'three': 'four',
-            },
-        }
-        output = serializer.index(fixture)
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="three">
-                    four
-                </meta>
-                <meta key="one">
-                    two
-                </meta>
-            </metadata>
-        """.replace("  ", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
-
-    def test_index_xml_null_value(self):
-        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
-        fixture = {
-            'metadata': {
-                'three': None,
-            },
-        }
-        output = serializer.index(fixture)
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="three">
-                    None
-                </meta>
-            </metadata>
-        """.replace("  ", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
-
     def test_show(self):
         req = webob.Request.blank('/v1.1/images/1/meta/key1')
         req.environ['api.version'] = '1.1'
@@ -166,24 +123,6 @@ class ImageMetaDataTest(unittest.TestCase):
         self.assertEqual(len(res_dict['meta']), 1)
         self.assertEqual('value1', res_dict['meta']['key1'])
 
-    def test_show_xml(self):
-        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
-        fixture = {
-            'meta': {
-                'one': 'two',
-            },
-        }
-        output = serializer.show(fixture)
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <meta xmlns="http://docs.openstack.org/compute/api/v1.1" key="one">
-                two
-            </meta>
-        """.replace("  ", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
-
     def test_show_not_found(self):
         req = webob.Request.blank('/v1.1/images/1/meta/key9')
         req.environ['api.version'] = '1.1'
@@ -205,34 +144,6 @@ class ImageMetaDataTest(unittest.TestCase):
         self.assertEqual('value2', res_dict['metadata']['key2'])
         self.assertEqual(1, len(res_dict))
 
-    def test_create_xml(self):
-        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
-        fixture = {
-            'metadata': {
-                'key9': 'value9',
-                'key2': 'value2',
-                'key1': 'value1',
-            },
-        }
-        output = serializer.create(fixture)
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="key2">
-                    value2
-                </meta>
-                <meta key="key9">
-                    value9
-                </meta>
-                <meta key="key1">
-                    value1
-                </meta>
-            </metadata>
-        """.replace("  ", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
-
     def test_update_item(self):
         req = webob.Request.blank('/v1.1/images/1/meta/key1')
         req.environ['api.version'] = '1.1'
@@ -255,24 +166,6 @@ class ImageMetaDataTest(unittest.TestCase):
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, res.status_int)
 
-    def test_update_item_xml(self):
-        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
-        fixture = {
-            'meta': {
-                'one': 'two',
-            },
-        }
-        output = serializer.update(fixture)
-        actual = minidom.parseString(output.replace("  ", ""))
-
-        expected = minidom.parseString("""
-            <meta xmlns="http://docs.openstack.org/compute/api/v1.1" key="one">
-                two
-            </meta>
-        """.replace("  ", ""))
-
-        self.assertEqual(expected.toxml(), actual.toxml())
-
     def test_update_item_too_many_keys(self):
         req = webob.Request.blank('/v1.1/images/1/meta/key1')
         req.environ['api.version'] = '1.1'
@@ -326,3 +219,134 @@ class ImageMetaDataTest(unittest.TestCase):
         req.headers["content-type"] = "application/json"
         res = req.get_response(fakes.wsgi_app())
         self.assertEqual(400, res.status_int)
+
+
+class ImageMetadataXMLSerializationTest(test.TestCase):
+
+    def test_index_xml(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'metadata': {
+                'one': 'two',
+                'three': 'four',
+            },
+        }
+        output = serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <meta key="three">
+                    four
+                </meta>
+                <meta key="one">
+                    two
+                </meta>
+            </metadata>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index_xml_null_value(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'metadata': {
+                'three': None,
+            },
+        }
+        output = serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <meta key="three">
+                    None
+                </meta>
+            </metadata>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_index_xml_unicode_value(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'metadata': {
+                'three': u'asdf',
+            },
+        }
+        output = serializer.serialize(fixture, 'index')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <meta key="three">
+                    asdf
+                </meta>
+            </metadata>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_show_xml(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'meta': {
+                'one': 'two',
+            },
+        }
+        output = serializer.serialize(fixture, 'show')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <meta xmlns="http://docs.openstack.org/compute/api/v1.1" key="one">
+                two
+            </meta>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_update_item_xml(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'meta': {
+                'one': 'two',
+            },
+        }
+        output = serializer.serialize(fixture, 'update')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <meta xmlns="http://docs.openstack.org/compute/api/v1.1" key="one">
+                two
+            </meta>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
+
+    def test_create_xml(self):
+        serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
+        fixture = {
+            'metadata': {
+                'key9': 'value9',
+                'key2': 'value2',
+                'key1': 'value1',
+            },
+        }
+        output = serializer.serialize(fixture, 'create')
+        actual = minidom.parseString(output.replace("  ", ""))
+
+        expected = minidom.parseString("""
+            <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
+                <meta key="key2">
+                    value2
+                </meta>
+                <meta key="key9">
+                    value9
+                </meta>
+                <meta key="key1">
+                    value1
+                </meta>
+            </metadata>
+        """.replace("  ", ""))
+
+        self.assertEqual(expected.toxml(), actual.toxml())
-- 
cgit 


From 7746fffe58e91eadf6597b13e166f6a3e5894c53 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Mon, 27 Jun 2011 11:27:25 -0400
Subject: making image metadata key in xml serialization test unicode

---
 nova/tests/api/openstack/test_image_metadata.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 9544389dd..874b7cb4b 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -271,7 +271,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
-                'three': u'asdf',
+                u'three': u'asdf',
             },
         }
         output = serializer.serialize(fixture, 'index')
-- 
cgit 


From 8df250af09b6319d5dc70d42469121f04401548f Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Mon, 27 Jun 2011 11:29:29 -0400
Subject: making key in images metadata xml serialization test null as well

---
 nova/api/openstack/image_metadata.py            | 2 +-
 nova/tests/api/openstack/test_image_metadata.py | 6 +++---
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index 7b138dc27..d72a9e0a4 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -117,7 +117,7 @@ class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
 
     def _meta_item_to_xml(self, doc, key, value):
         node = doc.createElement('meta')
-        node.setAttribute('key', key)
+        node.setAttribute('key', str(key))
         text = doc.createTextNode(str(value))
         node.appendChild(text)
         return node
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 874b7cb4b..a91d61d8f 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -247,11 +247,11 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_index_xml_null_value(self):
+    def test_index_xml_null_key_and_value(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
-                'three': None,
+                None: None,
             },
         }
         output = serializer.serialize(fixture, 'index')
@@ -259,7 +259,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         expected = minidom.parseString("""
             <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
-                <meta key="three">
+                <meta key="None">
                     None
                 </meta>
             </metadata>
-- 
cgit 


From c16f97249e4f0626f8b8d4a7af070201641770b8 Mon Sep 17 00:00:00 2001
From: Johannes Erdfelt <johannes.erdfelt@rackspace.com>
Date: Mon, 27 Jun 2011 15:54:43 +0000
Subject: Clarify help verbiage

---
 nova/virt/xenapi/vmops.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index ad096f7eb..1e908f513 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -48,7 +48,8 @@ LOG = logging.getLogger("nova.virt.xenapi.vmops")
 
 FLAGS = flags.FLAGS
 flags.DEFINE_integer('windows_version_timeout', 300,
-                     'time to wait for windows agent to be fully operational')
+                     'number of seconds to wait for windows agent to be '
+                     'fully operational')
 
 
 def cmp_version(a, b):
-- 
cgit 


From b74a01924511a46f0cb0279163349a8a68000cc4 Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Mon, 27 Jun 2011 13:51:30 -0400
Subject: renaming tests

---
 nova/tests/api/openstack/test_image_metadata.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index a91d61d8f..5db3caab9 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -247,7 +247,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_index_xml_null_key_and_value(self):
+    def test_index_xml_null(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
@@ -267,7 +267,7 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-    def test_index_xml_unicode_value(self):
+    def test_index_xml_unicode(self):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
-- 
cgit 


From dc90a10e399310c5a2781970874ea0e747f62670 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Mon, 27 Jun 2011 15:05:37 -0700
Subject: Made _issue_novaclient_command() behave better. Fixed a bunch of
 tests.

---
 nova/scheduler/api.py                             | 49 ++++++++++++++++-------
 nova/scheduler/zone_aware_scheduler.py            |  4 +-
 nova/tests/scheduler/test_least_cost_scheduler.py | 11 ++---
 nova/tests/scheduler/test_scheduler.py            |  4 +-
 nova/tests/scheduler/test_zone_aware_scheduler.py | 35 +++++++---------
 5 files changed, 60 insertions(+), 43 deletions(-)

diff --git a/nova/scheduler/api.py b/nova/scheduler/api.py
index 0aed75680..5d62beb86 100644
--- a/nova/scheduler/api.py
+++ b/nova/scheduler/api.py
@@ -162,32 +162,53 @@ def child_zone_helper(zone_list, func):
                     _wrap_method(_process, func), zone_list)]
 
 
-def _issue_novaclient_command(nova, zone, collection, method_name, item_id):
+def _issue_novaclient_command(nova, zone, collection,
+        method_name, *args, **kwargs):
     """Use novaclient to issue command to a single child zone.
-       One of these will be run in parallel for each child zone."""
+       One of these will be run in parallel for each child zone.
+    """
     manager = getattr(nova, collection)
-    result = None
-    try:
+
+    # NOTE(comstud): This is not ideal, but we have to do this based on
+    # how novaclient is implemented right now.
+    # 'find' is special cased as novaclient requires kwargs for it to
+    # filter on a 'get_all'.
+    # Every other method first needs to do a 'get' on the first argument
+    # passed, which should be a UUID.  If it's 'get' itself that we want,
+    # we just return the result.  Otherwise, we next call the real method
+    # that's wanted... passing other arguments that may or may not exist.
+    if method_name in ['find', 'findall']:
         try:
-            result = manager.get(item_id)
-        except ValueError, e:
-            result = manager.find(name=item_id)
+            return getattr(manager, method_name)(**kwargs)
+        except novaclient.NotFound:
+            url = zone.api_url
+            LOG.debug(_("%(collection)s.%(method_name)s didn't find "
+                    "anything matching '%(kwargs)s' on '%(url)s'" %
+                    locals()))
+            return None
+
+    args = list(args)
+    # pop off the UUID to look up
+    item = args.pop(0)
+    try:
+        result = manager.get(item)
     except novaclient.NotFound:
         url = zone.api_url
-        LOG.debug(_("%(collection)s '%(item_id)s' not found on '%(url)s'" %
+        LOG.debug(_("%(collection)s '%(item)s' not found on '%(url)s'" %
                                                 locals()))
         return None
 
-    if method_name.lower() not in ['get', 'find']:
-        result = getattr(result, method_name)()
+    if method_name.lower() != 'get':
+        # if we're doing something other than 'get', call it passing args.
+        result = getattr(result, method_name)(*args, **kwargs)
     return result
 
 
-def wrap_novaclient_function(f, collection, method_name, item_id):
-    """Appends collection, method_name and item_id to the incoming
+def wrap_novaclient_function(f, collection, method_name, *args, **kwargs):
+    """Appends collection, method_name and arguments to the incoming
     (nova, zone) call from child_zone_helper."""
     def inner(nova, zone):
-        return f(nova, zone, collection, method_name, item_id)
+        return f(nova, zone, collection, method_name, *args, **kwargs)
 
     return inner
 
@@ -220,7 +241,7 @@ class reroute_compute(object):
            the wrapped method. (This ensures that zone-local code can
            continue to use integer IDs).
 
-        4. If the item was not found, we delgate the call to a child zone
+        4. If the item was not found, we delegate the call to a child zone
            using the UUID.
     """
     def __init__(self, method_name):
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index e24c2256f..eb116fac4 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -180,7 +180,7 @@ class ZoneAwareScheduler(driver.Scheduler):
                                     request_spec, kwargs)
             return None
 
-        num_instances = request_spec['num_instances']
+        num_instances = request_spec.get('num_instances', 1)
         LOG.debug(_("Attemping to build %d instance%s") %
             (num_instances, "" if num_instances == 1 else "s"))
 
@@ -227,7 +227,7 @@ class ZoneAwareScheduler(driver.Scheduler):
             raise NotImplemented(_("Zone Aware Scheduler only understands "
                                    "Compute nodes (for now)"))
 
-        num_instances = request_spec['num_instances']
+        num_instances = request_spec.get('num_instances', 1)
         instance_type = request_spec['instance_type']
 
         weighted = []
diff --git a/nova/tests/scheduler/test_least_cost_scheduler.py b/nova/tests/scheduler/test_least_cost_scheduler.py
index 9a5318aee..49791053e 100644
--- a/nova/tests/scheduler/test_least_cost_scheduler.py
+++ b/nova/tests/scheduler/test_least_cost_scheduler.py
@@ -122,15 +122,16 @@ class LeastCostSchedulerTestCase(test.TestCase):
                     for hostname, caps in hosts]
         self.assertWeights(expected, num, request_spec, hosts)
 
-    def test_fill_first_cost_fn(self):
+    def test_compute_fill_first_cost_fn(self):
         FLAGS.least_cost_scheduler_cost_functions = [
-            'nova.scheduler.least_cost.fill_first_cost_fn',
+            'nova.scheduler.least_cost.compute_fill_first_cost_fn',
         ]
-        FLAGS.fill_first_cost_fn_weight = 1
+        FLAGS.compute_fill_first_cost_fn_weight = 1
 
         num = 1
-        request_spec = {}
-        hosts = self.sched.filter_hosts(num, request_spec)
+        instance_type = {'memory_mb': 1024}
+        request_spec = {'instance_type': instance_type}
+        hosts = self.sched.filter_hosts('compute', request_spec, None)
 
         expected = []
         for idx, (hostname, caps) in enumerate(hosts):
diff --git a/nova/tests/scheduler/test_scheduler.py b/nova/tests/scheduler/test_scheduler.py
index 4be59d411..fea8b424d 100644
--- a/nova/tests/scheduler/test_scheduler.py
+++ b/nova/tests/scheduler/test_scheduler.py
@@ -1074,7 +1074,7 @@ class DynamicNovaClientTest(test.TestCase):
 
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeServerCollection()),
-                    zone, "servers", "find", "name").b, 22)
+                    zone, "servers", "find", name="test").b, 22)
 
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeServerCollection()),
@@ -1088,7 +1088,7 @@ class DynamicNovaClientTest(test.TestCase):
 
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeEmptyServerCollection()),
-                    zone, "servers", "find", "name"), None)
+                    zone, "servers", "find", name="test"), None)
 
         self.assertEquals(api._issue_novaclient_command(
                     FakeNovaClient(FakeEmptyServerCollection()),
diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index 37c6488cc..b2599f1b8 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -55,29 +55,21 @@ def fake_zone_manager_service_states(num_hosts):
 
 
 class FakeZoneAwareScheduler(zone_aware_scheduler.ZoneAwareScheduler):
-    def filter_hosts(self, num, specs):
-        # NOTE(sirp): this is returning [(hostname, services)]
-        return self.zone_manager.service_states.items()
-
-    def weigh_hosts(self, num, specs, hosts):
-        fake_weight = 99
-        weighted = []
-        for hostname, caps in hosts:
-            weighted.append(dict(weight=fake_weight, name=hostname))
-        return weighted
+    # No need to stub anything at the moment
+    pass
 
 
 class FakeZoneManager(zone_manager.ZoneManager):
     def __init__(self):
         self.service_states = {
             'host1': {
-                'compute': {'ram': 1000},
+                'compute': {'host_memory_free': 1000*1024*1024},
             },
             'host2': {
-                'compute': {'ram': 2000},
+                'compute': {'host_memory_free': 2000*1024*1024},
             },
             'host3': {
-                'compute': {'ram': 3000},
+                'compute': {'host_memory_free': 3000*1024*1024},
             },
         }
 
@@ -164,13 +156,17 @@ class ZoneAwareSchedulerTestCase(test.TestCase):
         sched.set_zone_manager(zm)
 
         fake_context = {}
-        build_plan = sched.select(fake_context, {})
+        build_plan = sched.select(fake_context,
+                {'instance_type': {'memory_mb': 512},
+                    'num_instances': 4 })
 
-        self.assertEqual(15, len(build_plan))
+        # 4 from local zones, 12 from remotes
+        self.assertEqual(16, len(build_plan))
 
-        hostnames = [plan_item['name']
-                     for plan_item in build_plan if 'name' in plan_item]
-        self.assertEqual(3, len(hostnames))
+        hostnames = [plan_item['hostname']
+                     for plan_item in build_plan if 'hostname' in plan_item]
+        # 4 local hosts
+        self.assertEqual(4, len(hostnames))
 
     def test_empty_zone_aware_scheduler(self):
         """
@@ -185,8 +181,7 @@ class ZoneAwareSchedulerTestCase(test.TestCase):
         fake_context = {}
         self.assertRaises(driver.NoValidHost, sched.schedule_run_instance,
                           fake_context, 1,
-                          dict(host_filter=None,
-                               request_spec={'instance_type': {}}))
+                          dict(host_filter=None, instance_type={}))
 
     def test_schedule_do_not_schedule_with_hint(self):
         """
-- 
cgit 


From c293506c435222d8154618ffda89108d3f1ef692 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Mon, 27 Jun 2011 15:17:19 -0700
Subject: logging fixes

---
 nova/scheduler/zone_aware_scheduler.py | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index eb116fac4..638072ee7 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -181,8 +181,7 @@ class ZoneAwareScheduler(driver.Scheduler):
             return None
 
         num_instances = request_spec.get('num_instances', 1)
-        LOG.debug(_("Attemping to build %d instance%s") %
-            (num_instances, "" if num_instances == 1 else "s"))
+        LOG.debug(_("Attemping to build %d instance(s)") % locals())
 
         # Create build plan and provision ...
         build_plan = self.select(context, request_spec)
@@ -245,7 +244,7 @@ class ZoneAwareScheduler(driver.Scheduler):
             host_list = self.filter_hosts(topic, request_spec, host_list)
             if not host_list:
                 LOG.warn(_("Ran out of available hosts after weighing "
-                        "%d of %d instances") % (i, num_instances))
+                        "%(i)d of %(num_instances)d instances") % locals())
                 break
 
             # then weigh the selected hosts.
-- 
cgit 


From 9653ee5cfae198355610ff40f0820eb9071a0deb Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Tue, 28 Jun 2011 08:08:13 -0700
Subject: log formatting typo pep8 fixes

---
 nova/scheduler/zone_aware_scheduler.py            | 3 ++-
 nova/tests/scheduler/test_zone_aware_scheduler.py | 8 ++++----
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 638072ee7..2efad7bf2 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -181,7 +181,8 @@ class ZoneAwareScheduler(driver.Scheduler):
             return None
 
         num_instances = request_spec.get('num_instances', 1)
-        LOG.debug(_("Attemping to build %d instance(s)") % locals())
+        LOG.debug(_("Attempting to build %(num_instances)d instance(s)") %
+                locals())
 
         # Create build plan and provision ...
         build_plan = self.select(context, request_spec)
diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index b2599f1b8..1e23e3ee6 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -63,13 +63,13 @@ class FakeZoneManager(zone_manager.ZoneManager):
     def __init__(self):
         self.service_states = {
             'host1': {
-                'compute': {'host_memory_free': 1000*1024*1024},
+                'compute': {'host_memory_free': 1073741824},
             },
             'host2': {
-                'compute': {'host_memory_free': 2000*1024*1024},
+                'compute': {'host_memory_free': 2147483648},
             },
             'host3': {
-                'compute': {'host_memory_free': 3000*1024*1024},
+                'compute': {'host_memory_free': 3221225472},
             },
         }
 
@@ -158,7 +158,7 @@ class ZoneAwareSchedulerTestCase(test.TestCase):
         fake_context = {}
         build_plan = sched.select(fake_context,
                 {'instance_type': {'memory_mb': 512},
-                    'num_instances': 4 })
+                    'num_instances': 4})
 
         # 4 from local zones, 12 from remotes
         self.assertEqual(16, len(build_plan))
-- 
cgit 


From e611d3210911bfb6276da495d0b3943d2ce1b511 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Tue, 28 Jun 2011 08:12:08 -0700
Subject: update a test docstring to make it clear we're testing multiple
 instance builds

---
 nova/tests/scheduler/test_zone_aware_scheduler.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index 1e23e3ee6..32f5150a5 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -146,8 +146,8 @@ class ZoneAwareSchedulerTestCase(test.TestCase):
 
     def test_zone_aware_scheduler(self):
         """
-        Create a nested set of FakeZones, ensure that a select call returns the
-        appropriate build plan.
+        Create a nested set of FakeZones, try to build multiple instances
+        and ensure that a select call returns the appropriate build plan.
         """
         sched = FakeZoneAwareScheduler()
         self.stubs.Set(sched, '_call_zone_method', fake_call_zone_method)
-- 
cgit 


From 37e86a230720921488ae19fc2ca92667e8be4485 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Tue, 28 Jun 2011 08:53:13 -0700
Subject: change variable names to remove future conflict with sandy's
 zone-offsets branch

---
 nova/scheduler/zone_aware_scheduler.py | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 2efad7bf2..2e6662a79 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -192,9 +192,10 @@ class ZoneAwareScheduler(driver.Scheduler):
         for num in xrange(num_instances):
             if not build_plan:
                 break
-            item = build_plan.pop(0)
-            self._provision_resource(context, item, instance_id,
-                    request_spec, kwargs)
+
+            build_plan_item = build_plan.pop(0)
+            self._provision_resource(context, build_plan_item, instance_id,
+                                     request_spec, kwargs)
 
         # Returning None short-circuits the routing to Compute (since
         # we've already done it here)
-- 
cgit 


From 2ba837877344bc791d7361f622be288c1870ffda Mon Sep 17 00:00:00 2001
From: Brian Waldon <brian.waldon@rackspace.com>
Date: Tue, 28 Jun 2011 11:59:46 -0400
Subject: adding unicode support to image metadata

---
 nova/api/openstack/image_metadata.py            | 11 +++++++----
 nova/tests/api/openstack/test_image_metadata.py |  8 ++++----
 2 files changed, 11 insertions(+), 8 deletions(-)

diff --git a/nova/api/openstack/image_metadata.py b/nova/api/openstack/image_metadata.py
index d72a9e0a4..638b1ec15 100644
--- a/nova/api/openstack/image_metadata.py
+++ b/nova/api/openstack/image_metadata.py
@@ -117,8 +117,9 @@ class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
 
     def _meta_item_to_xml(self, doc, key, value):
         node = doc.createElement('meta')
-        node.setAttribute('key', str(key))
-        text = doc.createTextNode(str(value))
+        doc.appendChild(node)
+        node.setAttribute('key', '%s' % key)
+        text = doc.createTextNode('%s' % value)
         node.appendChild(text)
         return node
 
@@ -133,8 +134,9 @@ class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
         xml_doc = minidom.Document()
         items = metadata_dict['metadata'].items()
         container_node = self.meta_list_to_xml(xml_doc, items)
+        xml_doc.appendChild(container_node)
         self._add_xmlns(container_node)
-        return container_node.toprettyxml(indent='    ')
+        return xml_doc.toprettyxml(indent='    ', encoding='UTF-8')
 
     def index(self, metadata_dict):
         return self._meta_list_to_xml_string(metadata_dict)
@@ -146,8 +148,9 @@ class ImageMetadataXMLSerializer(wsgi.XMLDictSerializer):
         xml_doc = minidom.Document()
         item_key, item_value = meta_item_dict.items()[0]
         item_node = self._meta_item_to_xml(xml_doc, item_key, item_value)
+        xml_doc.appendChild(item_node)
         self._add_xmlns(item_node)
-        return item_node.toprettyxml(indent='    ')
+        return xml_doc.toprettyxml(indent='    ', encoding='UTF-8')
 
     def show(self, meta_item_dict):
         return self._meta_item_to_xml_string(meta_item_dict['meta'])
diff --git a/nova/tests/api/openstack/test_image_metadata.py b/nova/tests/api/openstack/test_image_metadata.py
index 5db3caab9..d9fb61e2a 100644
--- a/nova/tests/api/openstack/test_image_metadata.py
+++ b/nova/tests/api/openstack/test_image_metadata.py
@@ -271,19 +271,19 @@ class ImageMetadataXMLSerializationTest(test.TestCase):
         serializer = openstack.image_metadata.ImageMetadataXMLSerializer()
         fixture = {
             'metadata': {
-                u'three': u'asdf',
+                u'three': u'Jos\xe9',
             },
         }
         output = serializer.serialize(fixture, 'index')
         actual = minidom.parseString(output.replace("  ", ""))
 
-        expected = minidom.parseString("""
+        expected = minidom.parseString(u"""
             <metadata xmlns="http://docs.openstack.org/compute/api/v1.1">
                 <meta key="three">
-                    asdf
+                    Jos\xe9
                 </meta>
             </metadata>
-        """.replace("  ", ""))
+        """.encode("UTF-8").replace("  ", ""))
 
         self.assertEqual(expected.toxml(), actual.toxml())
 
-- 
cgit 


From d1adc2d969570049921370450e942e349deed840 Mon Sep 17 00:00:00 2001
From: Yuriy Taraday <yorik.sar@gmail.com>
Date: Wed, 29 Jun 2011 13:17:16 +0400
Subject: Remove unnessesary (and possibly failing) encoding.

---
 nova/compute/api.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 844192404..16ae07272 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -65,7 +65,7 @@ def generate_default_hostname(instance):
         else:
             table += '\0'
             deletions += c
-    return display_name.encode('latin-1', 'ignore').translate(table, deletions)
+    return display_name.translate(table, deletions)
 
 
 class API(base.Base):
-- 
cgit 


From 90556a857d0c3187115f401a637cd4ae1134ce05 Mon Sep 17 00:00:00 2001
From: Yuriy Taraday <yorik.sar@gmail.com>
Date: Wed, 29 Jun 2011 13:37:24 +0400
Subject: Add test for hostname generation.

---
 nova/tests/test_compute.py | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 8af2665bd..11ae7403c 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -160,6 +160,18 @@ class ComputeTestCase(test.TestCase):
             db.security_group_destroy(self.context, group['id'])
             db.instance_destroy(self.context, ref[0]['id'])
 
+    def test_default_hostname_generator(self):
+        cases = [(None, 'server_1'), ('Hello, Server!', 'hello_server'),
+                 ('<}\x1fh\x10e\x08l\x02l\x05o\x12!{>', 'hello')]
+        for display_name, hostname in cases:
+            ref = self.compute_api.create(self.context,
+                instance_types.get_default_instance_type(), None,
+                display_name=display_name)
+            try:
+                self.assertEqual(ref[0]['hostname'], hostname)
+            finally:
+                db.instance_destroy(self.context, ref[0]['id'])
+        
     def test_destroy_instance_disassociates_security_groups(self):
         """Make sure destroying disassociates security groups"""
         group = self._create_group()
-- 
cgit 


From c8d27dd68d449df77106c9cdf45b63c25fcb18ca Mon Sep 17 00:00:00 2001
From: Yuriy Taraday <yorik.sar@gmail.com>
Date: Wed, 29 Jun 2011 14:07:59 +0400
Subject: Brought back that encode under condition.

---
 nova/compute/api.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index 16ae07272..aa62e72cd 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -65,6 +65,8 @@ def generate_default_hostname(instance):
         else:
             table += '\0'
             deletions += c
+    if isinstance(display_name, unicode):
+        display_name = display_name.encode('latin-1', 'ignore')
     return display_name.translate(table, deletions)
 
 
-- 
cgit 


From de4a165a9d817b0422bcbeda8d59516d839745c8 Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 29 Jun 2011 08:29:13 -0700
Subject: pip requires

---
 tools/pip-requires | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/pip-requires b/tools/pip-requires
index bf4f7139d..dec93c351 100644
--- a/tools/pip-requires
+++ b/tools/pip-requires
@@ -9,7 +9,7 @@ boto==1.9b
 carrot==0.10.5
 eventlet
 lockfile==0.8
-python-novaclient==2.5.5
+python-novaclient==2.5.7
 python-daemon==1.5.5
 python-gflags==1.3
 redis==2.0.0
-- 
cgit 


From 6af4a9ded53efe4ca5c3aad1f3a621cc73513fb0 Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Wed, 29 Jun 2011 08:30:21 -0700
Subject: updated pip-requires for novaclient

---
 tools/pip-requires | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/pip-requires b/tools/pip-requires
index 6e686b7e7..dec93c351 100644
--- a/tools/pip-requires
+++ b/tools/pip-requires
@@ -9,7 +9,7 @@ boto==1.9b
 carrot==0.10.5
 eventlet
 lockfile==0.8
-python-novaclient==2.5.3
+python-novaclient==2.5.7
 python-daemon==1.5.5
 python-gflags==1.3
 redis==2.0.0
-- 
cgit 


From 68b313077578870908ebcc5b668df67ce921929a Mon Sep 17 00:00:00 2001
From: Johannes Erdfelt <johannes.erdfelt@rackspace.com>
Date: Wed, 29 Jun 2011 16:08:34 +0000
Subject: check_domid_changes is superfluous right now since it's only used
 when timeout is used. So simplify code a little bit

---
 nova/virt/xenapi/vmops.py | 21 +++++++++------------
 1 file changed, 9 insertions(+), 12 deletions(-)

diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 1e908f513..22ef0eb67 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -258,8 +258,7 @@ class VMOps(object):
                 # need to be more patient than normal as well as watch for
                 # domid changes
                 version = self.get_agent_version(instance,
-                                  timeout=FLAGS.windows_version_timeout,
-                                  check_domid_changes=True)
+                                  timeout=FLAGS.windows_version_timeout)
             else:
                 version = self.get_agent_version(instance)
             if not version:
@@ -516,8 +515,7 @@ class VMOps(object):
         task = self._session.call_xenapi('Async.VM.clean_reboot', vm_ref)
         self._session.wait_for_task(task, instance.id)
 
-    def get_agent_version(self, instance, timeout=None,
-                          check_domid_changes=False):
+    def get_agent_version(self, instance, timeout=None):
         """Get the version of the agent running on the VM instance."""
 
         def _call():
@@ -543,14 +541,13 @@ class VMOps(object):
                 if ret:
                     return ret
 
-                if check_domid_changes:
-                    vm_rec = self._session.get_xenapi().VM.get_record(vm_ref)
-                    if vm_rec['domid'] != domid:
-                        LOG.info(_('domid changed from %(olddomid)s to '
-                                   '%(newdomid)s') % {
-                                       'olddomid': domid,
-                                        'newdomid': vm_rec['domid']})
-                        domid = vm_rec['domid']
+                vm_rec = self._session.get_xenapi().VM.get_record(vm_ref)
+                if vm_rec['domid'] != domid:
+                    LOG.info(_('domid changed from %(olddomid)s to '
+                               '%(newdomid)s') % {
+                                   'olddomid': domid,
+                                    'newdomid': vm_rec['domid']})
+                    domid = vm_rec['domid']
         else:
             return _call()
 
-- 
cgit 


From 291df3a09a9970ad9ab0b236c93afe4d2a46920e Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Wed, 29 Jun 2011 09:29:07 -0700
Subject: removed extra stubout, switched to isinstance and catching explicit
 exception

---
 nova/compute/api.py                               |  2 +-
 nova/scheduler/zone_aware_scheduler.py            |  2 +-
 nova/tests/scheduler/test_zone_aware_scheduler.py | 10 ----------
 3 files changed, 2 insertions(+), 12 deletions(-)

diff --git a/nova/compute/api.py b/nova/compute/api.py
index b8c76c2f9..39ba06380 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -260,7 +260,7 @@ class API(base.Base):
         elevated = context.elevated()
         if security_group is None:
             security_group = ['default']
-        if not type(security_group) is list:
+        if not isinstance(security_group, list):
             security_group = [security_group]
 
         security_groups = []
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index dcfef6af5..fe033e24e 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -194,7 +194,7 @@ class ZoneAwareScheduler(driver.Scheduler):
                         cooked_weight = offset + scale * raw_weight
                         item['weight'] = cooked_weight
                         item['raw_weight'] = raw_weight
-                    except Exception, e:
+                    except KeyError:
                         LOG.exception(_("Bad child zone scaling values "
                                         "for Zone: %(zone)s") % locals())
 
diff --git a/nova/tests/scheduler/test_zone_aware_scheduler.py b/nova/tests/scheduler/test_zone_aware_scheduler.py
index 5c9df7fb0..832d9e6f1 100644
--- a/nova/tests/scheduler/test_zone_aware_scheduler.py
+++ b/nova/tests/scheduler/test_zone_aware_scheduler.py
@@ -16,8 +16,6 @@
 Tests For Zone Aware Scheduler.
 """
 
-import stubout
-
 import nova.db
 
 from nova import exception
@@ -170,14 +168,6 @@ def fake_zone_get_all(context):
 class ZoneAwareSchedulerTestCase(test.TestCase):
     """Test case for Zone Aware Scheduler."""
 
-    def setUp(self):
-        super(ZoneAwareSchedulerTestCase, self).setUp()
-        self.stubs = stubout.StubOutForTesting()
-
-    def tearDown(self):
-        self.stubs.UnsetAll()
-        super(ZoneAwareSchedulerTestCase, self).tearDown()
-
     def test_zone_aware_scheduler(self):
         """
         Create a nested set of FakeZones, ensure that a select call returns the
-- 
cgit 


From 5b634ef5ed8bfd0acf81291a2f80eb7975738c36 Mon Sep 17 00:00:00 2001
From: Vishvananda Ishaya <vishvananda@gmail.com>
Date: Wed, 29 Jun 2011 11:00:37 -0700
Subject: Make sure test setup is run for subdirectories

---
 nova/tests/api/__init__.py           | 19 +++++++++++++++++++
 nova/tests/api/openstack/__init__.py |  3 +++
 nova/tests/image/__init__.py         |  3 +++
 nova/tests/integrated/__init__.py    |  2 ++
 nova/tests/scheduler/__init__.py     | 19 +++++++++++++++++++
 5 files changed, 46 insertions(+)

diff --git a/nova/tests/api/__init__.py b/nova/tests/api/__init__.py
index e69de29bb..6dab802f2 100644
--- a/nova/tests/api/__init__.py
+++ b/nova/tests/api/__init__.py
@@ -0,0 +1,19 @@
+# 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.
+
+# NOTE(vish): this forces the fixtures from tests/__init.py:setup() to work
+from nova.tests import *
diff --git a/nova/tests/api/openstack/__init__.py b/nova/tests/api/openstack/__init__.py
index bac7181f7..bfb424afe 100644
--- a/nova/tests/api/openstack/__init__.py
+++ b/nova/tests/api/openstack/__init__.py
@@ -15,6 +15,9 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
+# NOTE(vish): this forces the fixtures from tests/__init.py:setup() to work
+from nova.tests import *
+
 import webob.dec
 from nova import test
 
diff --git a/nova/tests/image/__init__.py b/nova/tests/image/__init__.py
index b94e2e54e..6dab802f2 100644
--- a/nova/tests/image/__init__.py
+++ b/nova/tests/image/__init__.py
@@ -14,3 +14,6 @@
 #    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 #    License for the specific language governing permissions and limitations
 #    under the License.
+
+# NOTE(vish): this forces the fixtures from tests/__init.py:setup() to work
+from nova.tests import *
diff --git a/nova/tests/integrated/__init__.py b/nova/tests/integrated/__init__.py
index 10e0a91d7..430af8754 100644
--- a/nova/tests/integrated/__init__.py
+++ b/nova/tests/integrated/__init__.py
@@ -18,3 +18,5 @@
 :mod:`integrated` -- Tests whole systems, using mock services where needed
 =================================
 """
+# NOTE(vish): this forces the fixtures from tests/__init.py:setup() to work
+from nova.tests import *
diff --git a/nova/tests/scheduler/__init__.py b/nova/tests/scheduler/__init__.py
index e69de29bb..6dab802f2 100644
--- a/nova/tests/scheduler/__init__.py
+++ b/nova/tests/scheduler/__init__.py
@@ -0,0 +1,19 @@
+# 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.
+
+# NOTE(vish): this forces the fixtures from tests/__init.py:setup() to work
+from nova.tests import *
-- 
cgit 


From 851802e772095b646a7570bf0cc0c6d32be4643c Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Wed, 29 Jun 2011 12:23:26 -0700
Subject: Fixed indentation issues Fixed min/max_count checking issues Fixed a
 wrongly log message when zone aware scheduler finds no suitable hosts

---
 nova/api/openstack/create_instance_helper.py | 11 +++++++++--
 nova/api/openstack/servers.py                | 12 ++++++------
 nova/compute/api.py                          | 13 +++++++------
 nova/scheduler/zone_aware_scheduler.py       |  2 +-
 4 files changed, 23 insertions(+), 15 deletions(-)

diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 4c6cc0f83..2cc38911a 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -116,9 +116,16 @@ class CreateInstanceHelper(object):
         reservation_id = body['server'].get('reservation_id')
         min_count = body['server'].get('min_count')
         max_count = body['server'].get('max_count')
-        if min_count:
+        # min_count and max_count are optional.  If they exist, they come
+        # in as strings.  We want to default 'min_count' to 1, and default
+        # 'max_count' to be 'min_count'.
+        if not min_count:
+            min_count = 1
+        else:
             min_count = int(min_count)
-        if max_count:
+        if not max_count:
+            max_count = min_count
+        else:
             max_count = int(max_count)
         if min_count > max_count:
             min_count = max_count
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index decbfd6e6..66ef97af0 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -83,11 +83,11 @@ class Controller(object):
         recurse_zones = query_str.get('recurse_zones')
         recurse_zones = recurse_zones and True or False
         instance_list = self.compute_api.get_all(
-                                            req.environ['nova.context'],
-                                            reservation_id=reservation_id,
-                                            project_id=project_id,
-                                            fixed_ip=fixed_ip,
-                                            recurse_zones=recurse_zones)
+                req.environ['nova.context'],
+                reservation_id=reservation_id,
+                project_id=project_id,
+                fixed_ip=fixed_ip,
+                recurse_zones=recurse_zones)
         limited_list = self._limit_items(instance_list, req)
         builder = self._get_view_builder(req)
         servers = [builder.build(inst, is_detail)['server']
@@ -120,7 +120,7 @@ class Controller(object):
         result = None
         try:
             extra_values, instances = self.helper.create_instance(
-                                    req, body, self.compute_api.create)
+                    req, body, self.compute_api.create)
         except faults.Fault, f:
             return f
 
diff --git a/nova/compute/api.py b/nova/compute/api.py
index 1092ec727..92b87e75c 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -657,12 +657,13 @@ class API(base.Base):
             return instances
 
         admin_context = context.elevated()
-        children = scheduler_api.call_zone_method(admin_context, "list",
-                                novaclient_collection_name="servers",
-                                reservation_id=reservation_id,
-                                project_id=project_id,
-                                fixed_ip=fixed_ip,
-                                recurse_zones=True)
+        children = scheduler_api.call_zone_method(admin_context,
+                "list",
+                novaclient_collection_name="servers",
+                reservation_id=reservation_id,
+                project_id=project_id,
+                fixed_ip=fixed_ip,
+                recurse_zones=True)
 
         for zone, servers in children:
             for server in servers:
diff --git a/nova/scheduler/zone_aware_scheduler.py b/nova/scheduler/zone_aware_scheduler.py
index 2e6662a79..9e4fc47d1 100644
--- a/nova/scheduler/zone_aware_scheduler.py
+++ b/nova/scheduler/zone_aware_scheduler.py
@@ -245,7 +245,7 @@ class ZoneAwareScheduler(driver.Scheduler):
             # may have been consumed from a previous build..
             host_list = self.filter_hosts(topic, request_spec, host_list)
             if not host_list:
-                LOG.warn(_("Ran out of available hosts after weighing "
+                LOG.warn(_("Filter returned no hosts after processing "
                         "%(i)d of %(num_instances)d instances") % locals())
                 break
 
-- 
cgit 


From c1e799795e9634f4b56aaeb76c4a9553da3846e2 Mon Sep 17 00:00:00 2001
From: Johannes Erdfelt <johannes.erdfelt@rackspace.com>
Date: Wed, 29 Jun 2011 21:39:43 +0000
Subject: Rename one use of timeout to expiration to make the purpose clearer

---
 nova/virt/xenapi/vmops.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/nova/virt/xenapi/vmops.py b/nova/virt/xenapi/vmops.py
index 22ef0eb67..53d2d2cec 100644
--- a/nova/virt/xenapi/vmops.py
+++ b/nova/virt/xenapi/vmops.py
@@ -535,8 +535,8 @@ class VMOps(object):
 
             domid = vm_rec['domid']
 
-            timeout = time.time() + timeout
-            while time.time() < timeout:
+            expiration = time.time() + timeout
+            while time.time() < expiration:
                 ret = _call()
                 if ret:
                     return ret
-- 
cgit 


From 7555aca28a5ab1ba4dd1be04a91bf6347eaac84f Mon Sep 17 00:00:00 2001
From: Chris Behrens <cbehrens@codestud.com>
Date: Wed, 29 Jun 2011 15:22:56 -0700
Subject: fix issue of recurse_zones not being converted to bool properly add
 bool_from_str util call add test for bool_from_str slight rework of
 min/max_count check

---
 nova/api/openstack/create_instance_helper.py | 10 ++--------
 nova/api/openstack/servers.py                |  3 +--
 nova/tests/test_utils.py                     | 13 +++++++++++++
 nova/utils.py                                | 11 +++++++++++
 4 files changed, 27 insertions(+), 10 deletions(-)

diff --git a/nova/api/openstack/create_instance_helper.py b/nova/api/openstack/create_instance_helper.py
index 2cc38911a..1066713a3 100644
--- a/nova/api/openstack/create_instance_helper.py
+++ b/nova/api/openstack/create_instance_helper.py
@@ -119,14 +119,8 @@ class CreateInstanceHelper(object):
         # min_count and max_count are optional.  If they exist, they come
         # in as strings.  We want to default 'min_count' to 1, and default
         # 'max_count' to be 'min_count'.
-        if not min_count:
-            min_count = 1
-        else:
-            min_count = int(min_count)
-        if not max_count:
-            max_count = min_count
-        else:
-            max_count = int(max_count)
+        min_count = int(min_count) if min_count else 1
+        max_count = int(max_count) if max_count else min_count
         if min_count > max_count:
             min_count = max_count
 
diff --git a/nova/api/openstack/servers.py b/nova/api/openstack/servers.py
index 66ef97af0..fc1ab8d46 100644
--- a/nova/api/openstack/servers.py
+++ b/nova/api/openstack/servers.py
@@ -80,8 +80,7 @@ class Controller(object):
         reservation_id = query_str.get('reservation_id')
         project_id = query_str.get('project_id')
         fixed_ip = query_str.get('fixed_ip')
-        recurse_zones = query_str.get('recurse_zones')
-        recurse_zones = recurse_zones and True or False
+        recurse_zones = utils.bool_from_str(query_str.get('recurse_zones'))
         instance_list = self.compute_api.get_all(
                 req.environ['nova.context'],
                 reservation_id=reservation_id,
diff --git a/nova/tests/test_utils.py b/nova/tests/test_utils.py
index 3a3f914e4..0c359e981 100644
--- a/nova/tests/test_utils.py
+++ b/nova/tests/test_utils.py
@@ -276,6 +276,19 @@ class GenericUtilsTestCase(test.TestCase):
         result = utils.parse_server_string('www.exa:mple.com:8443')
         self.assertEqual(('', ''), result)
 
+    def test_bool_from_str(self):
+        self.assertTrue(utils.bool_from_str('1'))
+        self.assertTrue(utils.bool_from_str('2'))
+        self.assertTrue(utils.bool_from_str('-1'))
+        self.assertTrue(utils.bool_from_str('true'))
+        self.assertTrue(utils.bool_from_str('True'))
+        self.assertTrue(utils.bool_from_str('tRuE'))
+        self.assertFalse(utils.bool_from_str('False'))
+        self.assertFalse(utils.bool_from_str('false'))
+        self.assertFalse(utils.bool_from_str('0'))
+        self.assertFalse(utils.bool_from_str(None))
+        self.assertFalse(utils.bool_from_str('junk'))
+
 
 class IsUUIDLikeTestCase(test.TestCase):
     def assertUUIDLike(self, val, expected):
diff --git a/nova/utils.py b/nova/utils.py
index 510cdd9f6..be26899ca 100644
--- a/nova/utils.py
+++ b/nova/utils.py
@@ -772,6 +772,17 @@ def is_uuid_like(val):
     return (len(val) == 36) and (val.count('-') == 4)
 
 
+def bool_from_str(val):
+    """Convert a string representation of a bool into a bool value"""
+
+    if not val:
+        return False
+    try:
+        return True if int(val) else False
+    except ValueError:
+        return val.lower() == 'true'
+
+
 class Bootstrapper(object):
     """Provides environment bootstrapping capabilities for entry points."""
 
-- 
cgit 


From d1c5b8c9a5c54a7000d21451ff4649b1a772dfad Mon Sep 17 00:00:00 2001
From: Dan Prince <dan.prince@rackspace.com>
Date: Wed, 29 Jun 2011 22:50:39 -0400
Subject: Update the ec2 get_metadata handler so it works with the most recent
 version of the compute API get_all call which now returns a list if there is
 only a single record.

---
 nova/api/ec2/cloud.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/api/ec2/cloud.py b/nova/api/ec2/cloud.py
index 9aaf37a2d..25aeceea6 100644
--- a/nova/api/ec2/cloud.py
+++ b/nova/api/ec2/cloud.py
@@ -152,7 +152,7 @@ class CloudController(object):
 
         # This ensures that all attributes of the instance
         # are populated.
-        instance_ref = db.instance_get(ctxt, instance_ref['id'])
+        instance_ref = db.instance_get(ctxt, instance_ref[0]['id'])
 
         mpi = self._get_mpi_data(ctxt, instance_ref['project_id'])
         if instance_ref['key_name']:
-- 
cgit 


From 10df5ac36dbc4f6883833cbe25ad58b4629561fa Mon Sep 17 00:00:00 2001
From: Yuriy Taraday <yorik.sar@gmail.com>
Date: Thu, 30 Jun 2011 15:43:18 +0400
Subject: PEP8 fix.

---
 nova/tests/test_compute.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 11ae7403c..a53d94d77 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -171,7 +171,7 @@ class ComputeTestCase(test.TestCase):
                 self.assertEqual(ref[0]['hostname'], hostname)
             finally:
                 db.instance_destroy(self.context, ref[0]['id'])
-        
+
     def test_destroy_instance_disassociates_security_groups(self):
         """Make sure destroying disassociates security groups"""
         group = self._create_group()
-- 
cgit 


From e06542ed504847efbff8c59905c75ef99c512ecc Mon Sep 17 00:00:00 2001
From: Sandy Walsh <sandy.walsh@rackspace.com>
Date: Thu, 30 Jun 2011 11:02:57 -0700
Subject: blah

---
 nova/compute/manager.py | 1 -
 1 file changed, 1 deletion(-)

diff --git a/nova/compute/manager.py b/nova/compute/manager.py
index 98e02f5b2..af1226d1a 100644
--- a/nova/compute/manager.py
+++ b/nova/compute/manager.py
@@ -49,7 +49,6 @@ from nova import flags
 from nova import log as logging
 from nova import manager
 from nova import network
-from nova import notifier
 from nova import rpc
 from nova import utils
 from nova import volume
-- 
cgit