Added missing extension file and tests. Also modified the get_host_list() docstring to be more accurate about the return value.

nova/api/openstack/contrib/hosts.py

@@ -0,0 +1,112 @@
+# Copyright (c) 2011 Openstack, LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+"""The hosts admin extension."""
+
+from webob import exc
+
+from nova import compute
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova.api.openstack import common
+from nova.api.openstack import extensions
+from nova.api.openstack import faults
+from nova.scheduler import api as scheduler_api
+
+
+LOG = logging.getLogger("nova.api.hosts")
+FLAGS = flags.FLAGS
+
+
+def _list_hosts(req, service=None):
+    """Returns a summary list of hosts, optionally filtering
+    by service type.
+    """
+    context = req.environ['nova.context']
+    hosts = scheduler_api.get_host_list(context)
+    if service:
+        hosts = [host for host in hosts
+                if host["service"] == service]
+    return hosts
+
+
+def check_host(fn):
+    """Makes sure that the host exists."""
+    def wrapped(self, req, id, service=None, *args, **kwargs):
+        listed_hosts = _list_hosts(req, service)
+        hosts = [h["host_name"] for h in listed_hosts]
+        if id in hosts:
+            return fn(self, req, id, *args, **kwargs)
+        else:
+            raise exception.HostNotFound(host=id)
+    return wrapped
+
+
+class HostController(object):
+    """The Hosts API controller for the OpenStack API."""
+    def __init__(self):
+        self.compute_api = compute.API()
+        super(HostController, self).__init__()
+
+    def index(self, req):
+        return {'hosts': _list_hosts(req)}
+
+    @check_host
+    def update(self, req, id, body):
+        for raw_key, raw_val in body.iteritems():
+            key = raw_key.lower().strip()
+            val = raw_val.lower().strip()
+            # NOTE: (dabo) Right now only 'status' can be set, but other
+            # actions may follow.
+            if key == "status":
+                if val in ("enable", "disable"):
+                    return self._set_enabled_status(req, id,
+                            enabled=(val == "enable"))
+                else:
+                    raise ValueError(_("Invalid status: '%s'") % raw_val)
+            else:
+                raise ValueError(_("Invalid update setting: '%s'") % raw_key)
+
+    def _set_enabled_status(self, req, host, enabled):
+        """Sets the specified host's ability to accept new instances."""
+        context = req.environ['nova.context']
+        state = "enabled" if enabled else "disabled"
+        LOG.audit(_("Setting host %(host)s to %(state)s.") % locals())
+        result = self.compute_api.set_host_enabled(context, host=host,
+                enabled=enabled)
+        return {"host": host, "status": result}
+
+
+class Hosts(extensions.ExtensionDescriptor):
+    def get_name(self):
+        return "Hosts"
+
+    def get_alias(self):
+        return "os-hosts"
+
+    def get_description(self):
+        return "Host administration"
+
+    def get_namespace(self):
+        return "http://docs.openstack.org/ext/hosts/api/v1.1"
+
+    def get_updated(self):
+        return "2011-06-29T00:00:00+00:00"
+
+    def get_resources(self):
+        resources = [extensions.ResourceExtension('os-hosts', HostController(),
+                collection_actions={'update': 'PUT'}, member_actions={})]
+        return resources

nova/scheduler/zone_manager.py

@@ -116,8 +116,9 @@ class ZoneManager(object):
         return [zone.to_dict() for zone in self.zone_states.values()]
 
     def get_host_list(self):
-        """Returns a list of all the host names that the Zone Manager
-        knows about.
+        """Returns a list of dicts for each host that the Zone Manager
+        knows about. Each dict contains the host_name and the service
+        for that host.
         """
         all_hosts = self.service_states.keys()
         ret = []

nova/tests/test_hosts.py

@@ -0,0 +1,101 @@
+# Copyright (c) 2011 Openstack, LLC.
+# All Rights Reserved.
+#
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+
+import stubout
+
+from nova import context
+from nova import exception
+from nova import flags
+from nova import log as logging
+from nova import test
+from nova.api.openstack.contrib import hosts as os_hosts
+from nova.scheduler import api as scheduler_api
+
+
+FLAGS = flags.FLAGS
+LOG = logging.getLogger('nova.tests.hosts')
+# Simulate the hosts returned by the zone manager.
+HOST_LIST = [
+        {"host_name": "host_c1", "service": "compute"},
+        {"host_name": "host_c2", "service": "compute"},
+        {"host_name": "host_v1", "service": "volume"},
+        {"host_name": "host_v2", "service": "volume"}]
+
+
+def stub_get_host_list(req):
+    return HOST_LIST
+
+
+def stub_set_host_enabled(context, host, enabled):
+    # We'll simulate success and failure by assuming
+    # that 'host_c1' always succeeds, and 'host_c2'
+    # always fails
+    fail = (host == "host_c2")
+    status = "enabled" if (enabled ^ fail) else "disabled"
+    return status
+
+
+class FakeRequest(object):
+    environ = {"nova.context": context.get_admin_context()}
+
+
+class HostTestCase(test.TestCase):
+    """Test Case for hosts."""
+
+    def setUp(self):
+        super(HostTestCase, self).setUp()
+        self.controller = os_hosts.HostController()
+        self.req = FakeRequest()
+        self.stubs.Set(scheduler_api, 'get_host_list', stub_get_host_list)
+        self.stubs.Set(self.controller.compute_api, 'set_host_enabled',
+                stub_set_host_enabled)
+
+    def test_list_hosts(self):
+        """Verify that the compute hosts are returned."""
+        hosts = os_hosts._list_hosts(self.req)
+        self.assertEqual(hosts, HOST_LIST)
+
+        compute_hosts = os_hosts._list_hosts(self.req, "compute")
+        expected = [host for host in HOST_LIST
+                if host["service"] == "compute"]
+        self.assertEqual(compute_hosts, expected)
+
+    def test_disable_host(self):
+        dis_body = {"status": "disable"}
+        result_c1 = self.controller.update(self.req, "host_c1", body=dis_body)
+        self.assertEqual(result_c1["status"], "disabled")
+        result_c2 = self.controller.update(self.req, "host_c2", body=dis_body)
+        self.assertEqual(result_c2["status"], "enabled")
+
+    def test_enable_host(self):
+        en_body = {"status": "enable"}
+        result_c1 = self.controller.update(self.req, "host_c1", body=en_body)
+        self.assertEqual(result_c1["status"], "enabled")
+        result_c2 = self.controller.update(self.req, "host_c2", body=en_body)
+        self.assertEqual(result_c2["status"], "disabled")
+
+    def test_bad_status_value(self):
+        bad_body = {"status": "bad"}
+        self.assertRaises(ValueError, self.controller.update, self.req,
+                "host_c1", body=bad_body)
+
+    def test_bad_update_key(self):
+        bad_body = {"crazy": "bad"}
+        self.assertRaises(ValueError, self.controller.update, self.req,
+                "host_c1", body=bad_body)
+
+    def test_bad_host(self):
+        self.assertRaises(exception.HostNotFound, self.controller.update,
+                self.req, "bogus_host_name", body={"status": "disable"})