blueprint host-aggregates: OSAPI extensions

This commit introduces the OSAPI admin extensions for host aggregates.
This is part of a series of commits that have started with change:

https://review.openstack.org/#change,3035

Change-Id: If0c92dca7d6f5d794f84bdb2adc172c55dec6e74

7 files changed, 619 insertions, 4 deletions

diff --git a/etc/nova/policy.json b/etc/nova/policy.json
index d63934994..97961d0f3 100644
--- a/etc/nova/policy.json
+++ b/etc/nova/policy.json
@@ -12,6 +12,7 @@
     "admin_api": [["role:admin"]],
     "compute_extension:accounts": [["rule:admin_api"]],
     "compute_extension:admin_actions": [["rule:admin_api"]],
+    "compute_extension:aggregates": [["rule:admin_api"]],
     "compute_extension:certificates": [],
     "compute_extension:cloudpipe": [],
     "compute_extension:console_output": [],
diff --git a/nova/api/openstack/compute/contrib/aggregates.py b/nova/api/openstack/compute/contrib/aggregates.py
new file mode 100644
index 000000000..c0b0001e6
--- /dev/null
+++ b/nova/api/openstack/compute/contrib/aggregates.py
@@ -0,0 +1,223 @@
+# Copyright (c) 2012 Citrix Systems, Inc.
+# 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 Aggregate admin API extension."""
+
+from webob import exc
+
+from nova.api.openstack import extensions
+from nova import compute
+from nova import exception
+from nova import log as logging
+
+
+LOG = logging.getLogger("nova.api.openstack.compute.contrib.host_aggregates")
+authorize = extensions.extension_authorizer('compute', 'aggregates')
+
+
+def _get_context(req):
+    return req.environ['nova.context']
+
+
+def get_host_from_body(fn):
+    """Makes sure that the host exists."""
+    def wrapped(self, req, id, body, *args, **kwargs):
+        if len(body) == 1 and "host" in body:
+            host = body['host']
+        else:
+            raise exc.HTTPBadRequest
+        return fn(self, req, id, host, *args, **kwargs)
+    return wrapped
+
+
+class AggregateController(object):
+    """The Host Aggregates API controller for the OpenStack API."""
+    def __init__(self):
+        self.api = compute.AggregateAPI()
+
+    def index(self, req):
+        """Returns a list a host aggregate's id, name, availability_zone."""
+        context = _get_context(req)
+        authorize(context)
+        aggregates = self.api.get_aggregate_list(context)
+        return {'aggregates': aggregates}
+
+    def create(self, req, body):
+        """Creates an aggregate, given its name and availablity_zone."""
+        context = _get_context(req)
+        authorize(context)
+
+        if len(body) != 1:
+            raise exc.HTTPBadRequest
+        try:
+            host_aggregate = body["aggregate"]
+            aggregate_name = host_aggregate["name"]
+            availability_zone = host_aggregate["availability_zone"]
+        except KeyError:
+            raise exc.HTTPBadRequest
+        if len(host_aggregate) != 2:
+            raise exc.HTTPBadRequest
+
+        try:
+            aggregate = self.api.create_aggregate(context, aggregate_name,
+                                                  availability_zone)
+        except exception.AggregateNameExists:
+            raise exc.HTTPConflict
+        return self._marshall_aggregate(aggregate)
+
+    def show(self, req, id):
+        """Shows the details of an aggregate, hosts and metadata included."""
+        context = _get_context(req)
+        authorize(context)
+        try:
+            aggregate = self.api.get_aggregate(context, id)
+        except exception.AggregateNotFound:
+            raise exc.HTTPNotFound
+        return self._marshall_aggregate(aggregate)
+
+    def update(self, req, id, body):
+        """Updates the name and/or availbility_zone of given aggregate."""
+        context = _get_context(req)
+        authorize(context)
+        aggregate = id
+
+        if len(body) != 1:
+            raise exc.HTTPBadRequest
+        try:
+            updates = body["aggregate"]
+        except KeyError:
+            raise exc.HTTPBadRequest
+
+        if len(updates) < 1:
+            raise exc.HTTPBadRequest
+
+        for key in updates.keys():
+            if not key in ["name", "availability_zone"]:
+                raise exc.HTTPBadRequest
+
+        try:
+            aggregate = self.api.update_aggregate(context, aggregate, updates)
+        except exception.AggregateNotFound:
+            raise exc.HTTPNotFound
+
+        return self._marshall_aggregate(aggregate)
+
+    def delete(self, req, id):
+        """Removes an aggregate by id."""
+        context = _get_context(req)
+        authorize(context)
+        aggregate_id = id
+        try:
+            self.api.delete_aggregate(context, aggregate_id)
+        except exception.AggregateNotFound:
+            raise exc.HTTPNotFound
+
+    def action(self, req, id, body):
+        _actions = {
+            'add_host': self._add_host,
+            'remove_host': self._remove_host,
+            'set_metadata': self._set_metadata,
+        }
+        for action, data in body.iteritems():
+            try:
+                return _actions[action](req, id, data)
+            except KeyError:
+                msg = _("Aggregates does not have %s action") % action
+                raise exc.HTTPBadRequest(explanation=msg)
+
+        raise exc.HTTPBadRequest(explanation=_("Invalid request body"))
+
+    @get_host_from_body
+    def _add_host(self, req, id, host):
+        """Adds a host to the specified aggregate."""
+        context = _get_context(req)
+        authorize(context)
+        aggregate = id
+        try:
+            aggregate = self.api.add_host_to_aggregate(context,
+                                                       aggregate, host)
+        except exception.AggregateNotFound:
+            raise exc.HTTPNotFound
+        except exception.ComputeHostNotFound:
+            raise exc.HTTPNotFound
+        except exception.AggregateHostConflict:
+            raise exc.HTTPConflict
+        except exception.AggregateHostExists:
+            raise exc.HTTPConflict
+        except exception.InvalidAggregateAction:
+            raise exc.HTTPConflict
+        return self._marshall_aggregate(aggregate)
+
+    @get_host_from_body
+    def _remove_host(self, req, id, host):
+        """Removes a host from the specified aggregate."""
+        context = _get_context(req)
+        authorize(context)
+        aggregate = id
+        try:
+            aggregate = self.api.remove_host_from_aggregate(context,
+                                                            aggregate, host)
+        except exception.AggregateNotFound:
+            raise exc.HTTPNotFound
+        except exception.AggregateHostNotFound:
+            raise exc.HTTPNotFound
+        except exception.InvalidAggregateAction:
+            raise exc.HTTPConflict
+        return self._marshall_aggregate(aggregate)
+
+    def _set_metadata(self, req, id, body):
+        """Replaces the aggregate's existing metadata with new metadata."""
+        context = _get_context(req)
+        authorize(context)
+        aggregate = id
+
+        if len(body) != 1:
+            raise exc.HTTPBadRequest
+
+        try:
+            metadata = body["metadata"]
+        except KeyError:
+            raise exc.HTTPBadRequest
+
+        try:
+            aggregate = self.api.update_aggregate_metadata(context,
+                                                           aggregate, metadata)
+        except exception.AggregateNotFound:
+            raise exc.HTTPNotFound
+
+        return self._marshall_aggregate(aggregate)
+
+    def _marshall_aggregate(self, aggregate):
+        return {"aggregate": aggregate}
+
+
+class Aggregates(extensions.ExtensionDescriptor):
+    """Admin-only aggregate administration"""
+
+    name = "Aggregates"
+    alias = "os-aggregates"
+    namespace = "http://docs.openstack.org/compute/ext/aggregates/api/v1.1"
+    updated = "2012-01-12T00:00:00+00:00"
+
+    def __init__(self, ext_mgr):
+        ext_mgr.register(self)
+
+    def get_resources(self):
+        resources = []
+        res = extensions.ResourceExtension('os-aggregates',
+                AggregateController(),
+                member_actions={"action": "POST", })
+        resources.append(res)
+        return resources
diff --git a/nova/compute/api.py b/nova/compute/api.py
index fcc1f1652..0f1587dde 100644
--- a/nova/compute/api.py
+++ b/nova/compute/api.py
@@ -1849,10 +1849,14 @@ class AggregateAPI(base.Base):
                                       "args": {"aggregate_id": aggregate_id,
                                                "host": host}, })
             return self.get_aggregate(context, aggregate_id)
-        elif aggregate.operational_state == aggregate_states.DISMISSED:
-            raise exception.InvalidAggregateAction(action='add host',
-                                                   aggregate_id=aggregate_id,
-                                                   reason='aggregate deleted')
+        else:
+            invalid = {aggregate_states.CHANGING: 'setup in progress',
+                       aggregate_states.DISMISSED: 'aggregate deleted', }
+            if aggregate.operational_state in invalid.keys():
+                raise exception.\
+                    InvalidAggregateAction(action='remove host',
+                            aggregate_id=aggregate_id,
+                            reason=invalid[aggregate.operational_state])
 
     def _get_aggregate_info(self, context, aggregate):
         """Builds a dictionary with aggregate props, metadata and hosts."""
diff --git a/nova/tests/api/openstack/compute/contrib/test_aggregates.py b/nova/tests/api/openstack/compute/contrib/test_aggregates.py
new file mode 100644
index 000000000..a00dceba2
--- /dev/null
+++ b/nova/tests/api/openstack/compute/contrib/test_aggregates.py
@@ -0,0 +1,372 @@
+# Copyright (c) 2012 Citrix Systems, Inc.
+# 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.
+
+"""Tests for the aggregates admin api."""
+
+from webob import exc
+
+from nova.api.openstack.compute.contrib import aggregates
+from nova import context
+from nova import exception
+from nova import log as logging
+from nova import test
+
+
+LOG = logging.getLogger('nova.tests.aggregates')
+AGGREGATE_LIST = [
+        {"name": "aggregate1", "id": "1", "availability_zone": "nova1"},
+        {"name": "aggregate2", "id": "2", "availability_zone": "nova1"},
+        {"name": "aggregate3", "id": "3", "availability_zone": "nova2"},
+        {"name": "aggregate1", "id": "4", "availability_zone": "nova1"}]
+AGGREGATE = {"name": "aggregate1",
+                  "id": "1",
+                  "availability_zone": "nova1",
+                  "metadata": {"foo": "bar"},
+                  "hosts": ["host1, host2"]}
+
+
+class FakeRequest(object):
+    environ = {"nova.context": context.get_admin_context()}
+
+
+class AggregateTestCase(test.TestCase):
+    """Test Case for aggregates admin api."""
+
+    def setUp(self):
+        super(AggregateTestCase, self).setUp()
+        self.controller = aggregates.AggregateController()
+        self.req = FakeRequest()
+        self.context = self.req.environ['nova.context']
+
+    def test_index(self):
+        def stub_list_aggregates(context):
+            if context == None:
+                raise Exception()
+            return AGGREGATE_LIST
+        self.stubs.Set(self.controller.api, 'get_aggregate_list',
+                       stub_list_aggregates)
+
+        result = self.controller.index(self.req)
+
+        self.assertEqual(AGGREGATE_LIST, result["aggregates"])
+
+    def test_create(self):
+        def stub_create_aggregate(context, name, availability_zone):
+            self.assertEqual(context, self.context, "context")
+            self.assertEqual("test", name, "name")
+            self.assertEqual("nova1", availability_zone, "availability_zone")
+            return AGGREGATE
+        self.stubs.Set(self.controller.api, "create_aggregate",
+                       stub_create_aggregate)
+
+        result = self.controller.create(self.req, {"aggregate":
+                                          {"name": "test",
+                                           "availability_zone": "nova1"}})
+        self.assertEqual(AGGREGATE, result["aggregate"])
+
+    def test_create_with_duplicate_aggregate_name(self):
+        def stub_create_aggregate(context, name, availability_zone):
+            raise exception.AggregateNameExists
+        self.stubs.Set(self.controller.api, "create_aggregate",
+                       stub_create_aggregate)
+
+        self.assertRaises(exc.HTTPConflict, self.controller.create,
+                          self.req, {"aggregate":
+                                     {"name": "test",
+                                      "availability_zone": "nova1"}})
+
+    def test_create_with_no_aggregate(self):
+        self.assertRaises(exc.HTTPBadRequest, self.controller.create,
+                          self.req, {"foo":
+                                     {"name": "test",
+                                      "availability_zone": "nova1"}})
+
+    def test_create_with_no_name(self):
+        self.assertRaises(exc.HTTPBadRequest, self.controller.create,
+                          self.req, {"aggregate":
+                                     {"foo": "test",
+                                      "availability_zone": "nova1"}})
+
+    def test_create_with_no_availability_zone(self):
+        self.assertRaises(exc.HTTPBadRequest, self.controller.create,
+                          self.req, {"aggregate":
+                                     {"name": "test",
+                                      "foo": "nova1"}})
+
+    def test_create_with_extra_invalid_arg(self):
+        self.assertRaises(exc.HTTPBadRequest, self.controller.create,
+                          self.req, dict(name="test",
+                                         availablity_zone="nova1",
+                                         foo='bar'))
+
+    def test_show(self):
+        def stub_get_aggregate(context, id):
+            self.assertEqual(context, self.context, "context")
+            self.assertEqual("1", id, "id")
+            return AGGREGATE
+        self.stubs.Set(self.controller.api, 'get_aggregate',
+                       stub_get_aggregate)
+
+        aggregate = self.controller.show(self.req, "1")
+
+        self.assertEqual(AGGREGATE, aggregate["aggregate"])
+
+    def test_show_with_invalid_id(self):
+        def stub_get_aggregate(context, id):
+            raise exception.AggregateNotFound(aggregate_id=2)
+
+        self.stubs.Set(self.controller.api, 'get_aggregate',
+                       stub_get_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound,
+                          self.controller.show, self.req, "2")
+
+    def test_update(self):
+        body = {"aggregate": {"name": "new_name",
+                              "availability_zone": "nova1"}}
+
+        def stub_update_aggregate(context, aggregate, values):
+            self.assertEqual(context, self.context, "context")
+            self.assertEqual("1", aggregate, "aggregate")
+            self.assertEqual(body["aggregate"], values, "values")
+            return AGGREGATE
+        self.stubs.Set(self.controller.api, "update_aggregate",
+                       stub_update_aggregate)
+
+        result = self.controller.update(self.req, "1", body=body)
+
+        self.assertEqual(AGGREGATE, result["aggregate"])
+
+    def test_update_with_only_name(self):
+        body = {"aggregate": {"name": "new_name"}}
+
+        def stub_update_aggregate(context, aggregate, values):
+            return AGGREGATE
+        self.stubs.Set(self.controller.api, "update_aggregate",
+                       stub_update_aggregate)
+
+        result = self.controller.update(self.req, "1", body=body)
+
+        self.assertEqual(AGGREGATE, result["aggregate"])
+
+    def test_update_with_only_availability_zone(self):
+        body = {"aggregate": {"availability_zone": "nova1"}}
+
+        def stub_update_aggregate(context, aggregate, values):
+            return AGGREGATE
+        self.stubs.Set(self.controller.api, "update_aggregate",
+                       stub_update_aggregate)
+
+        result = self.controller.update(self.req, "1", body=body)
+
+        self.assertEqual(AGGREGATE, result["aggregate"])
+
+    def test_update_with_no_updates(self):
+        test_metadata = {"aggregate": {}}
+        self.assertRaises(exc.HTTPBadRequest, self.controller.update,
+                          self.req, "2", body=test_metadata)
+
+    def test_update_with_no_update_key(self):
+        test_metadata = {"asdf": {}}
+        self.assertRaises(exc.HTTPBadRequest, self.controller.update,
+                          self.req, "2", body=test_metadata)
+
+    def test_update_with_wrong_updates(self):
+        test_metadata = {"aggregate": {"status": "disable",
+                                     "foo": "bar"}}
+        self.assertRaises(exc.HTTPBadRequest, self.controller.update,
+                          self.req, "2", body=test_metadata)
+
+    def test_update_with_bad_host_aggregate(self):
+        test_metadata = {"aggregate": {"name": "test_name"}}
+
+        def stub_update_aggregate(context, aggregate, metadata):
+            raise exception.AggregateNotFound(aggregate_id=2)
+        self.stubs.Set(self.controller.api, "update_aggregate",
+                       stub_update_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound, self.controller.update,
+                self.req, "2", body=test_metadata)
+
+    def test_add_host(self):
+        def stub_add_host_to_aggregate(context, aggregate, host):
+            self.assertEqual(context, self.context, "context")
+            self.assertEqual("1", aggregate, "aggregate")
+            self.assertEqual("host1", host, "host")
+            return AGGREGATE
+        self.stubs.Set(self.controller.api, "add_host_to_aggregate",
+                       stub_add_host_to_aggregate)
+
+        aggregate = self.\
+                        controller.action(self.req, "1",
+                                          body={"add_host": {"host": "host1"}})
+
+        self.assertEqual(aggregate["aggregate"], AGGREGATE)
+
+    def test_add_host_with_already_added_to_another_aggregate(self):
+        def stub_add_host_to_aggregate(context, aggregate, host):
+            raise exception.AggregateHostConflict()
+        self.stubs.Set(self.controller.api, "add_host_to_aggregate",
+                       stub_add_host_to_aggregate)
+
+        self.assertRaises(exc.HTTPConflict, self.controller.action,
+                          self.req, "duplicate_aggregate",
+                          body={"add_host": {"host": "host1"}})
+
+    def test_add_host_with_already_added_host(self):
+        def stub_add_host_to_aggregate(context, aggregate, host):
+            raise exception.AggregateHostExists()
+        self.stubs.Set(self.controller.api, "add_host_to_aggregate",
+                       stub_add_host_to_aggregate)
+
+        self.assertRaises(exc.HTTPConflict, self.controller.action,
+                          self.req, "duplicate_aggregate",
+                          body={"add_host": {"host": "host1"}})
+
+    def test_add_host_with_bad_aggregate(self):
+        def stub_add_host_to_aggregate(context, aggregate, host):
+            raise exception.AggregateNotFound()
+        self.stubs.Set(self.controller.api, "add_host_to_aggregate",
+                       stub_add_host_to_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound, self.controller.action,
+                          self.req, "bogus_aggregate",
+                          body={"add_host": {"host": "host1"}})
+
+    def test_add_host_with_bad_host(self):
+        def stub_add_host_to_aggregate(context, aggregate, host):
+            raise exception.ComputeHostNotFound()
+        self.stubs.Set(self.controller.api, "add_host_to_aggregate",
+                       stub_add_host_to_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound, self.controller.action,
+                          self.req, "bogus_aggregate",
+                          body={"add_host": {"host": "host1"}})
+
+    def test_add_host_with_host_in_wrong_availability_zone(self):
+        def stub_add_host_to_aggregate(context, aggregate, host):
+            raise exception.InvalidAggregateAction()
+        self.stubs.Set(self.controller.api, "add_host_to_aggregate",
+                       stub_add_host_to_aggregate)
+
+        self.assertRaises(exc.HTTPConflict, self.controller.action,
+                          self.req, "bogus_aggregate",
+                          body={"add_host": {"host": "host1"}})
+
+    def test_add_host_with_missing_host(self):
+        self.assertRaises(exc.HTTPBadRequest, self.controller.action,
+                self.req, "1", body={"asdf": "asdf"})
+
+    def test_remove_host(self):
+        def stub_remove_host_from_aggregate(context, aggregate, host):
+            self.assertEqual(context, self.context, "context")
+            self.assertEqual("1", aggregate, "aggregate")
+            self.assertEqual("host1", host, "host")
+            stub_remove_host_from_aggregate.called = True
+        self.stubs.Set(self.controller.api,
+                       "remove_host_from_aggregate",
+                       stub_remove_host_from_aggregate)
+        self.controller.action(self.req, "1",
+                               body={"remove_host": {"host": "host1"}})
+
+        self.assertTrue(stub_remove_host_from_aggregate.called)
+
+    def test_remove_host_with_bad_aggregate(self):
+        def stub_remove_host_from_aggregate(context, aggregate, host):
+            raise exception.AggregateNotFound()
+        self.stubs.Set(self.controller.api,
+                       "remove_host_from_aggregate",
+                       stub_remove_host_from_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound, self.controller.action,
+                          self.req, "bogus_aggregate",
+                          body={"remove_host": {"host": "host1"}})
+
+    def test_remove_host_with_bad_host(self):
+        def stub_remove_host_from_aggregate(context, aggregate, host):
+            raise exception.AggregateHostNotFound()
+        self.stubs.Set(self.controller.api,
+                       "remove_host_from_aggregate",
+                       stub_remove_host_from_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound, self.controller.action,
+                          self.req, "bogus_aggregate",
+                          body={"remove_host": {"host": "host1"}})
+
+    def test_remove_host_with_missing_host(self):
+        self.assertRaises(exc.HTTPBadRequest, self.controller.action,
+                self.req, "1", body={"asdf": "asdf"})
+
+    def test_remove_host_with_extra_param(self):
+        self.assertRaises(exc.HTTPBadRequest, self.controller.action,
+                self.req, "1", body={"asdf": "asdf", "host": "asdf"})
+
+    def test_set_metadata(self):
+        body = {"set_metadata": {"metadata": {"foo": "bar"}}}
+
+        def stub_update_aggregate(context, aggregate, values):
+            self.assertEqual(context, self.context, "context")
+            self.assertEqual("1", aggregate, "aggregate")
+            self.assertDictMatch(body["set_metadata"]['metadata'], values)
+            return AGGREGATE
+        self.stubs.Set(self.controller.api,
+                       "update_aggregate_metadata",
+                       stub_update_aggregate)
+
+        result = self.controller.action(self.req, "1", body=body)
+
+        self.assertEqual(AGGREGATE, result["aggregate"])
+
+    def test_set_metadata_with_bad_host_aggregate(self):
+        body = {"set_metadata": {"metadata": {"foo": "bar"}}}
+
+        def stub_update_aggregate(context, aggregate, metadata):
+            raise exception.AggregateNotFound()
+        self.stubs.Set(self.controller.api,
+                       "update_aggregate_metadata",
+                       stub_update_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound, self.controller.action,
+                self.req, "bad_aggregate", body=body)
+
+    def test_set_metadata_with_missing_metadata(self):
+        body = {"asdf": {"foo": "bar"}}
+        self.assertRaises(exc.HTTPBadRequest, self.controller.action,
+                          self.req, "bad_aggregate", body=body)
+
+    def test_set_metadata_with_extra_params(self):
+        body = {"metadata": {"foo": "bar"}, "asdf": {"foo": "bar"}}
+        self.assertRaises(exc.HTTPBadRequest, self.controller.action,
+                          self.req, "bad_aggregate", body=body)
+
+    def test_delete_aggregate(self):
+        def stub_delete_aggregate(context, aggregate):
+            self.assertEqual(context, self.context, "context")
+            self.assertEqual("1", aggregate, "aggregate")
+            stub_delete_aggregate.called = True
+        self.stubs.Set(self.controller.api, "delete_aggregate",
+                       stub_delete_aggregate)
+
+        self.controller.delete(self.req, "1")
+        self.assertTrue(stub_delete_aggregate.called)
+
+    def test_delete_aggregate_with_bad_aggregate(self):
+        def stub_delete_aggregate(context, aggregate):
+            raise exception.AggregateNotFound()
+        self.stubs.Set(self.controller.api, "delete_aggregate",
+                       stub_delete_aggregate)
+
+        self.assertRaises(exc.HTTPNotFound, self.controller.delete,
+                self.req, "bogus_aggregate")
diff --git a/nova/tests/api/openstack/compute/test_extensions.py b/nova/tests/api/openstack/compute/test_extensions.py
index 3373e6410..adeb847a4 100644
--- a/nova/tests/api/openstack/compute/test_extensions.py
+++ b/nova/tests/api/openstack/compute/test_extensions.py
@@ -153,6 +153,7 @@ class ExtensionControllerTest(ExtensionTestCase):
         self.ext_list = [
             "Accounts",
             "AdminActions",
+            "Aggregates",
             "Certificates",
             "Cloudpipe",
             "Console_output",
diff --git a/nova/tests/policy.json b/nova/tests/policy.json
index 737e98f68..d899d455b 100644
--- a/nova/tests/policy.json
+++ b/nova/tests/policy.json
@@ -71,6 +71,7 @@
 
     "compute_extension:accounts": [],
     "compute_extension:admin_actions": [],
+    "compute_extension:aggregates": [],
     "compute_extension:certificates": [],
     "compute_extension:cloudpipe": [],
     "compute_extension:console_output": [],
diff --git a/nova/tests/test_compute.py b/nova/tests/test_compute.py
index 44938e5ba..881418168 100644
--- a/nova/tests/test_compute.py
+++ b/nova/tests/test_compute.py
@@ -3213,6 +3213,19 @@ class ComputeAPIAggrTestCase(test.TestCase):
                           self.api.remove_host_from_aggregate, self.context,
                           aggr['id'], 'fake_host')
 
+    def test_remove_host_from_aggregate_invalid_changing_status(self):
+        """Ensure InvalidAggregateAction is raised when aggregate is
+        changing."""
+        aggr = self.api.create_aggregate(self.context,
+                                         'fake_aggregate', 'fake_zone')
+        _create_service_entries(self.context, {'fake_zone': ['fake_host']})
+        # let's mock the fact that the aggregate is changing!
+        status = {'operational_state': aggregate_states.CHANGING}
+        db.aggregate_update(self.context, aggr['id'], status)
+        self.assertRaises(exception.InvalidAggregateAction,
+                          self.api.remove_host_from_aggregate, self.context,
+                          aggr['id'], 'fake_host')
+
     def test_remove_host_from_aggregate_raise_not_found(self):
         """Ensure ComputeHostNotFound is raised when removing invalid host."""
         aggr = self.api.create_aggregate(self.context, 'fake_aggregate',