From: Steven Hardy <shardy@redhat.com>
Date: Wed, 12 Dec 2012 15:01:54 +0000 (+0000)
Subject: heat cfn api, format waitcondition error responses correctly
X-Git-Tag: 2014.1~1085^2
X-Git-Url: https://review.fuel-infra.org/gitweb?a=commitdiff_plain;h=9ceadd6730d09707347b077385a36253a94ff258;p=openstack-build%2Fheat-build.git

heat cfn api, format waitcondition error responses correctly

Return errors from the waitcondition part of the CFN API in a similar
format to other CFN API responses, by catching engine errors and mapping
the error to an appropriate HeatAPIException.

fixes bug 1089032

Signed-off-by: Steven Hardy <shardy@redhat.com>
Change-Id: I40486ed53fd4968519f623a3ea5a96f6c3374ea5
---

diff --git a/heat/api/cfn/v1/waitcondition.py b/heat/api/cfn/v1/waitcondition.py
index a428d971..3d4d9215 100644
--- a/heat/api/cfn/v1/waitcondition.py
+++ b/heat/api/cfn/v1/waitcondition.py
@@ -13,8 +13,6 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-import json
-
 from webob.exc import Response
 
 from heat.common import wsgi
@@ -22,20 +20,8 @@ from heat.common import context
 from heat.rpc import client as rpc_client
 from heat.openstack.common import rpc
 from heat.common import identifier
-
-
-def json_response(http_status, data):
-    """Create a JSON response with a specific HTTP code."""
-    response = Response(json.dumps(data))
-    response.status = http_status
-    response.content_type = 'application/json'
-    return response
-
-
-def json_error(http_status, message):
-    """Create a JSON error response."""
-    body = {'error': message}
-    return json_response(http_status, body)
+from heat.api.aws import exception
+import heat.openstack.common.rpc.common as rpc_common
 
 
 class WaitConditionController:
@@ -46,22 +32,15 @@ class WaitConditionController:
     def update_waitcondition(self, req, body, arn):
         con = req.context
         identity = identifier.ResourceIdentifier.from_arn(arn)
-        [error, metadata] = self.engine.metadata_update(con,
-                                 stack_id=identity.stack_id,
-                                 resource_name=identity.resource_name,
-                                 metadata=body)
-        if error:
-            if error == 'stack':
-                return json_error(404,
-                        'The stack "%s" does not exist.' % identity.stack_id)
-            else:
-                return json_error(404,
-                        'The resource "%s" does not exist.' %
-                        identity.resource_name)
-        return json_response(201, {
-            'resource': identity.resource_name,
-            'metadata': body,
-        })
+        try:
+            md = self.engine.metadata_update(con,
+                     stack_id=identity.stack_id,
+                     resource_name=identity.resource_name,
+                     metadata=body)
+        except rpc_common.RemoteError as ex:
+            return exception.map_remote_error(ex)
+
+        return {'resource': identity.resource_name, 'metadata': md}
 
 
 def create_resource(options):
@@ -69,6 +48,4 @@ def create_resource(options):
     Stacks resource factory method.
     """
     deserializer = wsgi.JSONRequestDeserializer()
-    serializer = wsgi.JSONResponseSerializer()
-    return wsgi.Resource(WaitConditionController(options), deserializer,
-                         serializer)
+    return wsgi.Resource(WaitConditionController(options), deserializer)
diff --git a/heat/engine/service.py b/heat/engine/service.py
index 11efff66..0fa8eacd 100644
--- a/heat/engine/service.py
+++ b/heat/engine/service.py
@@ -412,19 +412,16 @@ class EngineService(service.Service):
         """
         s = db_api.stack_get(None, stack_id)
         if s is None:
-            logger.warn("Stack %s not found" % stack_id)
-            return ['stack', None]
+            raise AttributeError("Stack %s not found" % stack_id)
 
         stack = parser.Stack.load(None, stack=s)
         if resource_name not in stack:
-            logger.warn("Resource not found %s:%s." % (stack_id,
-                                                       resource_name))
-            return ['resource', None]
+            raise AttributeError("Resource not found %s" % resource_name)
 
         resource = stack[resource_name]
         resource.metadata = metadata
 
-        return [None, resource.metadata]
+        return resource.metadata
 
     def _periodic_watcher_task(self, sid):
         """
diff --git a/heat/tests/test_engine_service.py b/heat/tests/test_engine_service.py
index dc9e8402..135acb4c 100644
--- a/heat/tests/test_engine_service.py
+++ b/heat/tests/test_engine_service.py
@@ -611,12 +611,22 @@ class stackServiceTest(unittest.TestCase):
 
     def test_metadata(self):
         test_metadata = {'foo': 'bar', 'baz': 'quux', 'blarg': 'wibble'}
-        err, result = self.man.metadata_update(None,
-                                               self.stack.id, 'WebServer',
+        result = self.man.metadata_update(None, self.stack.id, 'WebServer',
                                                test_metadata)
-        self.assertEqual(err, None)
         self.assertEqual(result, test_metadata)
 
+    def test_metadata_err_stack(self):
+        test_metadata = {'foo': 'bar', 'baz': 'quux', 'blarg': 'wibble'}
+        self.assertRaises(AttributeError,
+                          self.man.metadata_update,
+                          None, 'noexistid', 'WebServer', test_metadata)
+
+    def test_metadata_err_resource(self):
+        test_metadata = {'foo': 'bar', 'baz': 'quux', 'blarg': 'wibble'}
+        self.assertRaises(AttributeError,
+                          self.man.metadata_update,
+                          None, self.stack.id, 'NooServer', test_metadata)
+
     def test_show_watch(self):
         # Insert two dummy watch rules into the DB
         values = {'stack_id': self.stack.id,