Merge lp:~sandy-walsh/nova/dist-sched-2a into lp:~hudson-openstack/nova/trunk

[Sandy Walsh]

Basic hook-up to HostFilter and fixed up the passing of InstanceType spec to the scheduler.

Basic hook-up to HostFilter and fixed up the passing of InstanceType spec to the scheduler.

[Sandy Walsh (sandy-walsh)]

Note that this merge is dependent on dist-sched-1.

This implies the diff below includes all of dist-sched-1 as well. Sorry for the clutter :/

[Todd Willey (xtoddx)]

Can you merge trunk so the diff gets updated?

[Sandy Walsh (sandy-walsh)]

all done ... thanks for the reminder Todd.

[Jay Pipes (jaypipes)]

Hi guys,

Couple things, mostly around trying to get the terminology a little more concrete. I'm hoping that you would be amenable to changing the term "driver" to simply be "filter" in the scheduler code. In some places, filters are called filters (in the class name and the docstrings). In other places, they're called drivers or filter drivers.

For instance:

36 +class InstanceTypeFilter(HostFilter):
37 + """HostFilter driver hard-coded to work with InstanceType records."""

I'd like to see that docstring say:

"""Type of filter that inspects/filters on attributes of an InstanceType"""

Similarly, here:

11 + 'filter_driver':
12 + 'nova.scheduler.host_filter.'
13 + 'InstanceTypeFilter'

Would just be:

'filter': 'nova.scheduler.host_filter.InstanceTypeFilter'

The reason I ask for this change is because, the term "driver" is already overloaded in the Nova code -- along with various terms like "manager".

Secondly, with the concept of a filter, you typically have the concept of "chaining". In other words, a filter merely removes elements of a set and returns the filtered set to the next filter in the chain. It would be good to be able to add multiple filters to the request.

Something like:

'filters': [
  {'filter': 'nova.scheduler.host_filter.InstanceTypeFilter',
   'on': instance_type},
  {'filter': 'nova.scheduler.network_filter.NetworkCapabilitiesFilter',
   'on': network_ref},
]

Just some thoughts to chew on. :)

Cheers,
jay

[Sandy Walsh (sandy-walsh)]

Good points. I'll clear up the "driver" thing. I agree fully.

Lemme stew on the chaining thing. Interesting idea. Perhaps that's something we can work into a coming merge?

[Jay Pipes (jaypipes)]

> Good points. I'll clear up the "driver" thing. I agree fully.

sweet :)

> Lemme stew on the chaining thing. Interesting idea. Perhaps that's something
> we can work into a coming merge?

Absolutely.

-jay

[Jay Pipes (jaypipes)]

11 + 'filter_driver':

Can we just make that 'filter'?

-jay

[Sandy Walsh (sandy-walsh)]

doh! Missed one :(

[Ed Leafe (ed-leafe)]

Several places: the standard for multiline docstrings is to put the closing tripquotes on their own line.

Starting on line 169: the comparison expression is long and cumbersome; it would read much better if it were broken into separate lines:
for filter_class in FILTERS:
    filter_match = "%s.%s" % (filter_class.__module__, filter_class.__name__)
    if filter_match == filter_name:
        return filter_class()

Diff line 290: you have a string format operator, but no format placeholders in the string.

Other than those relatively minor things, looks good!

[Sandy Walsh (sandy-walsh)]

Thanks Ed ... good stuff. I'll get right on it.

[Ed Leafe (ed-leafe)]

Looks like you misunderstood my docstring comment. Single line docstrings should be:

"""This is a simple docstring."""

Multi-line docstrings should be:

"""This is a more complex explanation.

It requires several lines to more fully explain
the details of this method.
"""

My comment was only about the *closing" triple quote. The opening tripquote does not get its own line.

[Jay Pipes (jaypipes)]

tiny weeny nit:

400 +from nova import rpc
401 from nova import log as logging

l comes before r :)

-jay

[Sandy Walsh (sandy-walsh)]

phooey ... I'll fix the docstrings (again). heh.

(and thanks again Jay, will fix)

[Brian Lamar (blamar)]

@ed

I seriously *hate* to be that guy because I think the multi-line docstring style you described is more aesthetically pleasing, but according to the HACKING file a multi-line docstring has a newline at the very end. I've had a number of merge proposals help up while I added newlines :)

[Ed Leafe (ed-leafe)]

That is the most vile standard. A tripquote all by itself is essentially a blank line. But I guess I'm preaching to the choir here. FWIW, I *never* follow that, and have not gotten dinged. (Please don't take that as a challenge with my next merge prop!) ;-)

[Jay Pipes (jaypipes)]

I'd like to propose we move to this standard:

"""T
he first character of the first line end then
.

After all, docstrings
 are more intere
sting when it's difficult to read what is
in it.

"""

[Joshua McKenty (joshua-mckenty)]

As long as we use \n\r for the first line break, and \n for the others.

Joshua McKenty
Piston Cloud Computing, Inc.
[phone]
<email address hidden>

On 2011-05-27, at 9:50 AM, Jay Pipes wrote:

> I'd like to propose we move to this standard:
>
> """T
> he first character of the first line end then
> .
>
> After all, docstrings
> are more intere
> sting when it's difficult to read what is
> in it.
>
>
>
>
>
> """
> --
> https://code.launchpad.net/~sandy-walsh/nova/dist-sched-2a/+merge/61245
> Your team Nova Core is requested to review the proposed merge of lp:~sandy-walsh/nova/dist-sched-2a into lp:nova.

[Ed Leafe (ed-leafe)]

> I'd like to propose we move to this standard:
>
> """T
> he first character of the first line end then
> .
>
> After all, docstrings
> are more intere
> sting when it's difficult to read what is
> in it.
>
>
>
>
>
> """

I'd like to see a mandatory blank line between every line with text in it. After all, since whitespace is a good thing, more of it is even better!

[Sandy Walsh (sandy-walsh)]

All docstrings should be formal haiku (with seasonal references).

(while this may not be getting me closer to approval on this branch ... it sure is fun)

-S

Confidentiality Notice: This e-mail message (including any attached or
embedded documents) is intended for the exclusive and confidential use of the
individual or entity to which this message is addressed, and unless otherwise
expressly indicated, is confidential and privileged information of Rackspace.
Any dissemination, distribution or copying of the enclosed material is prohibited.
If you receive this transmission in error, please notify us immediately by e-mail
at <email address hidden>, and delete the original message.
Your cooperation is appreciated.

[Rick Harris (rconradharris)]

Looks good. Let's get this merged so we can power through the rest of the dist-scheduler work :)

review: Approve

[Ed Leafe (ed-leafe)]

lgtm.

review: Approve

[OpenStack Infra (hudson-openstack)]

No proposals found for merge of lp:~rconradharris/nova/dist-sched-1 into lp:nova.

Unmerged revisions

=== modified file 'nova/compute/api.py'
--- nova/compute/api.py	2011-05-25 20:58:40 +0000
+++ nova/compute/api.py	2011-05-31 17:43:25 +0000
@@ -91,7 +91,6 @@
         """Enforce quota limits on injected files.
 
         Raises a QuotaError if any limit is exceeded.
-
         """
         if injected_files is None:
             return
@@ -140,7 +139,6 @@
         """Create the number and type of instances requested.
 
         Verifies that quota and other arguments are valid.
-
         """
         if not instance_type:
             instance_type = instance_types.get_default_instance_type()
@@ -268,7 +266,12 @@
                      {"method": "run_instance",
                       "args": {"topic": FLAGS.compute_topic,
                                "instance_id": instance_id,
-                               "instance_type": instance_type,
+                               "request_spec": {
+                                        'instance_type': instance_type,
+                                        'filter':
+                                            'nova.scheduler.host_filter.'
+                                            'InstanceTypeFilter'
+                                    },
                                "availability_zone": availability_zone,
                                "injected_files": injected_files,
                                "admin_password": admin_password}})
@@ -294,7 +297,6 @@
         already exist.
 
         :param context: the security context
-
         """
         try:
             db.security_group_get_by_name(context, context.project_id,
@@ -327,7 +329,6 @@
 
         Sends an update request to each compute node for whom this is
         relevant.
-
         """
         # First, we get the security group rules that reference this group as
         # the grantee..
@@ -374,7 +375,6 @@
                        updated
 
         :returns: None
-
         """
         rv = self.db.instance_update(context, instance_id, kwargs)
         return dict(rv.iteritems())
@@ -424,7 +424,6 @@
         Use this method instead of get() if this is the only operation you
         intend to to. It will route to novaclient.get if the instance is not
         found.
-
         """
         return self.get(context, instance_id)
 
@@ -434,7 +433,6 @@
 
         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.db.instance_get_all_by_reservation(
@@ -464,7 +462,6 @@
                        compute worker
 
         :returns: None
-
         """
         if not params:
             params = {}
@@ -514,7 +511,6 @@
         """Snapshot the given instance.
 
         :returns: A dict containing image metadata
-
         """
         properties = {'instance_id': str(instance_id),
                       'user_id': str(context.user_id)}

=== modified file 'nova/exception.py'
--- nova/exception.py	2011-05-27 04:37:39 +0000
+++ nova/exception.py	2011-05-31 17:43:25 +0000
@@ -473,9 +473,8 @@
     message = _("Zone %(zone_id)s could not be found.")
 
 
-class SchedulerHostFilterDriverNotFound(NotFound):
-    message = _("Scheduler Host Filter Driver %(driver_name)s could"
-                " not be found.")
+class SchedulerHostFilterNotFound(NotFound):
+    message = _("Scheduler Host Filter %(filter_name)s could not be found.")
 
 
 class InstanceMetadataNotFound(NotFound):

=== modified file 'nova/scheduler/host_filter.py'
--- nova/scheduler/host_filter.py	2011-05-09 19:57:56 +0000
+++ nova/scheduler/host_filter.py	2011-05-31 17:43:25 +0000
@@ -14,8 +14,8 @@
 #    under the License.
 
 """
-Host Filter is a driver mechanism for requesting instance resources.
-Three drivers are included: AllHosts, Flavor & JSON. AllHosts just
+Host Filter is a mechanism for requesting instance resources.
+Three filters are included: AllHosts, Flavor & JSON. AllHosts just
 returns the full, unfiltered list of hosts. Flavor is a hard coded
 matching mechanism based on flavor criteria and JSON is an ad-hoc
 filter grammar.
@@ -42,17 +42,18 @@
 from nova import flags
 from nova import log as logging
 from nova import utils
+from nova.scheduler import zone_aware_scheduler
 
 LOG = logging.getLogger('nova.scheduler.host_filter')
 
 FLAGS = flags.FLAGS
-flags.DEFINE_string('default_host_filter_driver',
+flags.DEFINE_string('default_host_filter',
                     'nova.scheduler.host_filter.AllHostsFilter',
-                    'Which driver to use for filtering hosts.')
+                    'Which filter to use for filtering hosts.')
 
 
 class HostFilter(object):
-    """Base class for host filter drivers."""
+    """Base class for host filters."""
 
     def instance_type_to_filter(self, instance_type):
         """Convert instance_type into a filter for most common use-case."""
@@ -63,14 +64,15 @@
         raise NotImplementedError()
 
     def _full_name(self):
-        """module.classname of the filter driver"""
+        """module.classname of the filter."""
         return "%s.%s" % (self.__module__, self.__class__.__name__)
 
 
 class AllHostsFilter(HostFilter):
-    """NOP host filter driver. Returns all hosts in ZoneManager.
+    """ NOP host filter. Returns all hosts in ZoneManager.
     This essentially does what the old Scheduler+Chance used
-    to give us."""
+    to give us.
+    """
 
     def instance_type_to_filter(self, instance_type):
         """Return anything to prevent base-class from raising
@@ -83,8 +85,8 @@
                for host, services in zone_manager.service_states.iteritems()]
 
 
-class FlavorFilter(HostFilter):
-    """HostFilter driver hard-coded to work with flavors."""
+class InstanceTypeFilter(HostFilter):
+    """HostFilter hard-coded to work with InstanceType records."""
 
     def instance_type_to_filter(self, instance_type):
         """Use instance_type to filter hosts."""
@@ -98,9 +100,10 @@
             capabilities = services.get('compute', {})
             host_ram_mb = capabilities['host_memory_free']
             disk_bytes = capabilities['disk_available']
-            if host_ram_mb >= instance_type['memory_mb'] and \
-                disk_bytes >= instance_type['local_gb']:
-                    selected_hosts.append((host, capabilities))
+            spec_ram = instance_type['memory_mb']
+            spec_disk = instance_type['local_gb']
+            if host_ram_mb >= spec_ram and disk_bytes >= spec_disk:
+                selected_hosts.append((host, capabilities))
         return selected_hosts
 
 #host entries (currently) are like:
@@ -109,15 +112,15 @@
 #    'host_memory_total': 8244539392,
 #    'host_memory_overhead': 184225792,
 #    'host_memory_free': 3868327936,
-#    'host_memory_free_computed': 3840843776},
-#    'host_other-config': {},
+#    'host_memory_free_computed': 3840843776,
+#    'host_other_config': {},
 #    'host_ip_address': '192.168.1.109',
 #    'host_cpu_info': {},
 #    'disk_available': 32954957824,
 #    'disk_total': 50394562560,
-#    'disk_used': 17439604736},
+#    'disk_used': 17439604736,
 #    'host_uuid': 'cedb9b39-9388-41df-8891-c5c9a0c0fe5f',
-#    'host_name-label': 'xs-mini'}
+#    'host_name_label': 'xs-mini'}
 
 # instance_type table has:
 #name = Column(String(255), unique=True)
@@ -131,8 +134,9 @@
 
 
 class JsonFilter(HostFilter):
-    """Host Filter driver to allow simple JSON-based grammar for
-       selecting hosts."""
+    """Host Filter to allow simple JSON-based grammar for
+    selecting hosts.
+    """
 
     def _equals(self, args):
         """First term is == all the other terms."""
@@ -228,7 +232,8 @@
 
     def _parse_string(self, string, host, services):
         """Strings prefixed with $ are capability lookups in the
-        form '$service.capability[.subcap*]'"""
+        form '$service.capability[.subcap*]'
+        """
         if not string:
             return None
         if string[0] != '$':
@@ -271,18 +276,48 @@
         return hosts
 
 
-DRIVERS = [AllHostsFilter, FlavorFilter, JsonFilter]
-
-
-def choose_driver(driver_name=None):
-    """Since the caller may specify which driver to use we need
-       to have an authoritative list of what is permissible. This
-       function checks the driver name against a predefined set
-       of acceptable drivers."""
-
-    if not driver_name:
-        driver_name = FLAGS.default_host_filter_driver
-    for driver in DRIVERS:
-        if "%s.%s" % (driver.__module__, driver.__name__) == driver_name:
-            return driver()
-    raise exception.SchedulerHostFilterDriverNotFound(driver_name=driver_name)
+FILTERS = [AllHostsFilter, InstanceTypeFilter, JsonFilter]
+
+
+def choose_host_filter(filter_name=None):
+    """Since the caller may specify which filter to use we need
+    to have an authoritative list of what is permissible. This
+    function checks the filter name against a predefined set
+    of acceptable filters.
+    """
+
+    if not filter_name:
+        filter_name = FLAGS.default_host_filter
+    for filter_class in FILTERS:
+        host_match = "%s.%s" % (filter_class.__module__, filter_class.__name__)
+        if host_match == filter_name:
+            return filter_class()
+    raise exception.SchedulerHostFilterNotFound(filter_name=filter_name)
+
+
+class HostFilterScheduler(zone_aware_scheduler.ZoneAwareScheduler):
+    """The HostFilterScheduler uses the HostFilter to filter
+    hosts for weighing. The particular filter used may be passed in
+    as an argument or the default will be used.
+
+    request_spec = {'filter': <Filter name>,
+                    'instance_type': <InstanceType dict>}
+    """
+
+    def filter_hosts(self, num, request_spec):
+        """Filter the full host list (from the ZoneManager)"""
+        filter_name = request_spec.get('filter', None)
+        host_filter = choose_host_filter(filter_name)
+
+        # TODO(sandy): We're only using InstanceType-based specs
+        # currently. Later we'll need to snoop for more detailed
+        # host filter requests.
+        instance_type = request_spec['instance_type']
+        name, query = 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):
+        """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]

=== modified file 'nova/scheduler/manager.py'
--- nova/scheduler/manager.py	2011-05-05 14:35:44 +0000
+++ nova/scheduler/manager.py	2011-05-31 17:43:25 +0000
@@ -83,11 +83,16 @@
         except AttributeError:
             host = self.driver.schedule(elevated, topic, *args, **kwargs)
 
+        if not host:
+            LOG.debug(_("%(topic)s %(method)s handled in Scheduler")
+                        % locals())
+            return
+
         rpc.cast(context,
                  db.queue_get_for(context, topic, host),
                  {"method": method,
                   "args": kwargs})
-        LOG.debug(_("Casting to %(topic)s %(host)s for %(method)s") % locals())
+        LOG.debug(_("Casted to %(topic)s %(host)s for %(method)s") % locals())
 
     # NOTE (masumotok) : This method should be moved to nova.api.ec2.admin.
     #                    Based on bexar design summit discussion,

=== modified file 'nova/scheduler/zone_aware_scheduler.py'
--- nova/scheduler/zone_aware_scheduler.py	2011-05-13 13:12:18 +0000
+++ nova/scheduler/zone_aware_scheduler.py	2011-05-31 17:43:25 +0000
@@ -22,7 +22,9 @@
 
 import operator
 
+from nova import db
 from nova import log as logging
+from nova import rpc
 from nova.scheduler import api
 from nova.scheduler import driver
 
@@ -36,7 +38,7 @@
         """Call novaclient zone method. Broken out for testing."""
         return api.call_zone_method(context, method, specs=specs)
 
-    def schedule_run_instance(self, context, topic='compute', specs={},
+    def schedule_run_instance(self, context, instance_id, request_spec,
                                         *args, **kwargs):
         """This method is called from nova.compute.api to provision
         an instance. However we need to look at the parameters being
@@ -44,56 +46,83 @@
         1. Create a Build Plan and then provision, or
         2. Use the Build Plan information in the request parameters
            to simply create the instance (either in this zone or
-           a child zone)."""
-
-        if 'blob' in specs:
-            return self.provision_instance(context, topic, specs)
+           a child zone).
+        """
+
+        # TODO(sandy): We'll have to look for richer specs at some point.
+
+        if 'blob' in request_spec:
+            self.provision_resource(context, request_spec, instance_id, kwargs)
+            return None
 
         # Create build plan and provision ...
-        build_plan = self.select(context, specs)
+        build_plan = self.select(context, request_spec)
+        if not build_plan:
+            raise driver.NoValidHost(_('No hosts were available'))
+
         for item in build_plan:
-            self.provision_instance(context, topic, item)
-
-    def provision_instance(context, topic, item):
-        """Create the requested instance in this Zone or a child zone."""
-        pass
-
-    def select(self, context, *args, **kwargs):
+            self.provision_resource(context, item, instance_id, kwargs)
+
+        # Returning None short-circuits the routing to Compute (since
+        # we've already done it here)
+        return None
+
+    def provision_resource(self, context, item, instance_id, kwargs):
+        """Create the requested resource in this Zone or a child zone."""
+        if "hostname" in item:
+            host = item['hostname']
+            kwargs['instance_id'] = instance_id
+            rpc.cast(context,
+                     db.queue_get_for(context, "compute", host),
+                     {"method": "run_instance",
+                      "args": kwargs})
+            LOG.debug(_("Casted to compute %(host)s for run_instance")
+                                % locals())
+        else:
+            # TODO(sandy) Provision in child zone ...
+            LOG.warning(_("Provision to Child Zone not supported (yet)"))
+            pass
+
+    def select(self, context, request_spec, *args, **kwargs):
         """Select returns a list of weights and zone/host information
         corresponding to the best hosts to service the request. Any
         child zone information has been encrypted so as not to reveal
-        anything about the children."""
-        return self._schedule(context, "compute", *args, **kwargs)
+        anything about the children.
+        """
+        return self._schedule(context, "compute", request_spec,
+                              *args, **kwargs)
 
-    def schedule(self, context, topic, *args, **kwargs):
+    # TODO(sandy): We're only focused on compute instances right now,
+    # so we don't implement the default "schedule()" method required
+    # of Schedulers.
+    def schedule(self, context, topic, request_spec, *args, **kwargs):
         """The schedule() contract requires we return the one
         best-suited host for this request.
         """
-        res = self._schedule(context, topic, *args, **kwargs)
-        # TODO(sirp): should this be a host object rather than a weight-dict?
-        if not res:
-            raise driver.NoValidHost(_('No hosts were available'))
-        return res[0]
+        raise driver.NoValidHost(_('No hosts were available'))
 
-    def _schedule(self, context, topic, *args, **kwargs):
+    def _schedule(self, context, topic, request_spec, *args, **kwargs):
         """Returns a list of hosts that meet the required specs,
         ordered by their fitness.
         """
 
-        #TODO(sandy): extract these from args.
+        if topic != "compute":
+            raise NotImplemented(_("Zone Aware Scheduler only understands "
+                                   "Compute nodes (for now)"))
+
+        #TODO(sandy): how to infer this from OS API params?
         num_instances = 1
-        specs = {}
 
         # Filter local hosts based on requirements ...
-        host_list = self.filter_hosts(num_instances, specs)
+        host_list = self.filter_hosts(num_instances, request_spec)
 
         # then weigh the selected hosts.
         # weighted = [{weight=weight, name=hostname}, ...]
-        weighted = self.weigh_hosts(num_instances, specs, host_list)
+        weighted = self.weigh_hosts(num_instances, request_spec, host_list)
 
         # Next, tack on the best weights from the child zones ...
         child_results = self._call_zone_method(context, "select",
-                specs=specs)
+                specs=request_spec)
         for child_zone, result in child_results:
             for weighting in result:
                 # Remember the child_zone so we can get back to
@@ -108,12 +137,14 @@
         weighted.sort(key=operator.itemgetter('weight'))
         return weighted
 
-    def filter_hosts(self, num, specs):
+    def filter_hosts(self, num, request_spec):
         """Derived classes must override this method and return
-           a list of hosts in [(hostname, capability_dict)] format."""
+        a list of hosts in [(hostname, capability_dict)] format.
+        """
         raise NotImplemented()
 
-    def weigh_hosts(self, num, specs, hosts):
+    def weigh_hosts(self, num, request_spec, hosts):
         """Derived classes must override this method and return
-           a lists of hosts in [{weight, hostname}] format."""
+        a lists of hosts in [{weight, hostname}] format.
+        """
         raise NotImplemented()

=== modified file 'nova/tests/test_host_filter.py'
--- nova/tests/test_host_filter.py	2011-05-09 16:08:56 +0000
+++ nova/tests/test_host_filter.py	2011-05-31 17:43:25 +0000
@@ -13,7 +13,7 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 """
-Tests For Scheduler Host Filter Drivers.
+Tests For Scheduler Host Filters.
 """
 
 import json
@@ -31,7 +31,7 @@
 
 
 class HostFilterTestCase(test.TestCase):
-    """Test case for host filter drivers."""
+    """Test case for host filters."""
 
     def _host_caps(self, multiplier):
         # Returns host capabilities in the following way:
@@ -57,8 +57,8 @@
                 'host_name-label': 'xs-%s' % multiplier}
 
     def setUp(self):
-        self.old_flag = FLAGS.default_host_filter_driver
-        FLAGS.default_host_filter_driver = \
+        self.old_flag = FLAGS.default_host_filter
+        FLAGS.default_host_filter = \
                             'nova.scheduler.host_filter.AllHostsFilter'
         self.instance_type = dict(name='tiny',
                 memory_mb=50,
@@ -76,51 +76,52 @@
         self.zone_manager.service_states = states
 
     def tearDown(self):
-        FLAGS.default_host_filter_driver = self.old_flag
+        FLAGS.default_host_filter = self.old_flag
 
-    def test_choose_driver(self):
-        # Test default driver ...
-        driver = host_filter.choose_driver()
-        self.assertEquals(driver._full_name(),
+    def test_choose_filter(self):
+        # Test default filter ...
+        hf = host_filter.choose_host_filter()
+        self.assertEquals(hf._full_name(),
                         'nova.scheduler.host_filter.AllHostsFilter')
-        # Test valid driver ...
-        driver = host_filter.choose_driver(
-                        'nova.scheduler.host_filter.FlavorFilter')
-        self.assertEquals(driver._full_name(),
-                        'nova.scheduler.host_filter.FlavorFilter')
-        # Test invalid driver ...
+        # Test valid filter ...
+        hf = host_filter.choose_host_filter(
+                        'nova.scheduler.host_filter.InstanceTypeFilter')
+        self.assertEquals(hf._full_name(),
+                        'nova.scheduler.host_filter.InstanceTypeFilter')
+        # Test invalid filter ...
         try:
-            host_filter.choose_driver('does not exist')
-            self.fail("Should not find driver")
-        except exception.SchedulerHostFilterDriverNotFound:
+            host_filter.choose_host_filter('does not exist')
+            self.fail("Should not find host filter.")
+        except exception.SchedulerHostFilterNotFound:
             pass
 
-    def test_all_host_driver(self):
-        driver = host_filter.AllHostsFilter()
-        cooked = driver.instance_type_to_filter(self.instance_type)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
+    def test_all_host_filter(self):
+        hf = host_filter.AllHostsFilter()
+        cooked = hf.instance_type_to_filter(self.instance_type)
+        hosts = hf.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(10, len(hosts))
         for host, capabilities in hosts:
             self.assertTrue(host.startswith('host'))
 
-    def test_flavor_driver(self):
-        driver = host_filter.FlavorFilter()
+    def test_instance_type_filter(self):
+        hf = host_filter.InstanceTypeFilter()
         # filter all hosts that can support 50 ram and 500 disk
-        name, cooked = driver.instance_type_to_filter(self.instance_type)
-        self.assertEquals('nova.scheduler.host_filter.FlavorFilter', name)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        name, cooked = hf.instance_type_to_filter(self.instance_type)
+        self.assertEquals('nova.scheduler.host_filter.InstanceTypeFilter',
+                          name)
+        hosts = hf.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(6, len(hosts))
         just_hosts = [host for host, caps in hosts]
         just_hosts.sort()
         self.assertEquals('host05', just_hosts[0])
         self.assertEquals('host10', just_hosts[5])
 
-    def test_json_driver(self):
-        driver = host_filter.JsonFilter()
+    def test_json_filter(self):
+        hf = host_filter.JsonFilter()
         # filter all hosts that can support 50 ram and 500 disk
-        name, cooked = driver.instance_type_to_filter(self.instance_type)
+        name, cooked = hf.instance_type_to_filter(self.instance_type)
         self.assertEquals('nova.scheduler.host_filter.JsonFilter', name)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        hosts = hf.filter_hosts(self.zone_manager, cooked)
         self.assertEquals(6, len(hosts))
         just_hosts = [host for host, caps in hosts]
         just_hosts.sort()
@@ -140,7 +141,7 @@
                    ]
               ]
         cooked = json.dumps(raw)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        hosts = hf.filter_hosts(self.zone_manager, cooked)
 
         self.assertEquals(5, len(hosts))
         just_hosts = [host for host, caps in hosts]
@@ -152,7 +153,7 @@
                   ['=', '$compute.host_memory_free', 30],
               ]
         cooked = json.dumps(raw)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        hosts = hf.filter_hosts(self.zone_manager, cooked)
 
         self.assertEquals(9, len(hosts))
         just_hosts = [host for host, caps in hosts]
@@ -162,7 +163,7 @@
 
         raw = ['in', '$compute.host_memory_free', 20, 40, 60, 80, 100]
         cooked = json.dumps(raw)
-        hosts = driver.filter_hosts(self.zone_manager, cooked)
+        hosts = hf.filter_hosts(self.zone_manager, cooked)
 
         self.assertEquals(5, len(hosts))
         just_hosts = [host for host, caps in hosts]
@@ -174,35 +175,32 @@
         raw = ['unknown command', ]
         cooked = json.dumps(raw)
         try:
-            driver.filter_hosts(self.zone_manager, cooked)
+            hf.filter_hosts(self.zone_manager, cooked)
             self.fail("Should give KeyError")
         except KeyError, e:
             pass
 
-        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps([])))
-        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps({})))
-        self.assertTrue(driver.filter_hosts(self.zone_manager, json.dumps(
+        self.assertTrue(hf.filter_hosts(self.zone_manager, json.dumps([])))
+        self.assertTrue(hf.filter_hosts(self.zone_manager, json.dumps({})))
+        self.assertTrue(hf.filter_hosts(self.zone_manager, json.dumps(
                 ['not', True, False, True, False]
             )))
 
         try:
-            driver.filter_hosts(self.zone_manager, json.dumps(
+            hf.filter_hosts(self.zone_manager, json.dumps(
                 'not', True, False, True, False
             ))
             self.fail("Should give KeyError")
         except KeyError, e:
             pass
 
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-                ['=', '$foo', 100]
-            )))
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-                ['=', '$.....', 100]
-            )))
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-            ['>', ['and', ['or', ['not', ['<', ['>=', ['<=', ['in', ]]]]]]]]
-        )))
+        self.assertFalse(hf.filter_hosts(self.zone_manager,
+                json.dumps(['=', '$foo', 100])))
+        self.assertFalse(hf.filter_hosts(self.zone_manager,
+                json.dumps(['=', '$.....', 100])))
+        self.assertFalse(hf.filter_hosts(self.zone_manager,
+                json.dumps(
+            ['>', ['and', ['or', ['not', ['<', ['>=', ['<=', ['in', ]]]]]]]])))
 
-        self.assertFalse(driver.filter_hosts(self.zone_manager, json.dumps(
-                ['=', {}, ['>', '$missing....foo']]
-            )))
+        self.assertFalse(hf.filter_hosts(self.zone_manager,
+                json.dumps(['=', {}, ['>', '$missing....foo']])))

=== modified file 'nova/tests/test_zone_aware_scheduler.py'
--- nova/tests/test_zone_aware_scheduler.py	2011-05-13 01:44:22 +0000
+++ nova/tests/test_zone_aware_scheduler.py	2011-05-31 17:43:25 +0000
@@ -116,4 +116,6 @@
         sched.set_zone_manager(zm)
 
         fake_context = {}
-        self.assertRaises(driver.NoValidHost, sched.schedule, fake_context, {})
+        self.assertRaises(driver.NoValidHost, sched.schedule_run_instance,
+                          fake_context, 1,
+                          dict(host_filter=None, instance_type={}))

=== modified file 'nova/virt/fake.py'
--- nova/virt/fake.py	2011-05-05 03:53:04 +0000
+++ nova/virt/fake.py	2011-05-31 17:43:25 +0000
@@ -82,6 +82,21 @@
 
     def __init__(self):
         self.instances = {}
+        self.host_status = {
+          'host_name-description': 'Fake Host',
+          'host_hostname': 'fake-mini',
+          'host_memory_total': 8000000000,
+          'host_memory_overhead': 10000000,
+          'host_memory_free': 7900000000,
+          'host_memory_free_computed': 7900000000,
+          'host_other_config': {},
+          'host_ip_address': '192.168.1.109',
+          'host_cpu_info': {},
+          'disk_available': 500000000000,
+          'disk_total': 600000000000,
+          'disk_used': 100000000000,
+          'host_uuid': 'cedb9b39-9388-41df-8891-c5c9a0c0fe5f',
+          'host_name_label': 'fake-mini'}
 
     @classmethod
     def instance(cls):
@@ -456,3 +471,11 @@
     def test_remove_vm(self, instance_name):
         """ Removes the named VM, as if it crashed. For testing"""
         self.instances.pop(instance_name)
+
+    def update_host_status(self):
+        """Return fake Host Status of ram, disk, network."""
+        return self.host_status
+
+    def get_host_stats(self, refresh=False):
+        """Return fake Host Status of ram, disk, network."""
+        return self.host_status