Add Vitrage template resource

The VitrageTemplate resource is responsible for
adding a Vitrage template. This template can be
used, for example, to execute a Mistral healing
workflow.

Depends-On: If05f0907d8f43f64327c7774170e5b559286fc06
Depends-On: I56560d014a02b5f2ddbc08689d39147fbe4ffca4
Change-Id: Ie862e88ccb82c819b93fa2dbc5f21af61b138046
Story: 2002684
Task: 22504

5 files changed, 324 insertions, 0 deletions

diff --git a/heat/engine/resources/openstack/vitrage/__init__.py b/heat/engine/resources/openstack/vitrage/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/heat/engine/resources/openstack/vitrage/__init__.py
diff --git a/heat/engine/resources/openstack/vitrage/vitrage_template.py b/heat/engine/resources/openstack/vitrage/vitrage_template.py
new file mode 100644
index 000000000..6f9b6c125
--- /dev/null
+++ b/heat/engine/resources/openstack/vitrage/vitrage_template.py
@@ -0,0 +1,135 @@
+#
+#    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.
+
+from oslo_log import log as logging
+
+from heat.common import exception
+from heat.common.i18n import _
+from heat.engine import properties
+from heat.engine import resource
+from heat.engine import support
+
+LOG = logging.getLogger(__name__)
+
+
+class VitrageTemplate(resource.Resource):
+    """A resource for managing Vitrage templates.
+
+    A Vitrage template defines conditions and actions, based on the Vitrage
+    topology graph. For example, if there is an "instance down" alarm on an
+    instance, then execute a Mistral healing workflow.
+
+    The VitrageTemplate resource generates and adds to Vitrage a template based
+    on the input parameters.
+    """
+
+    default_client_name = "vitrage"
+
+    support_status = support.SupportStatus(version='16.0.0')
+
+    TEMPLATE_NAME = 'template_name'
+
+    PROPERTIES = (
+        TEMPLATE_FILE, TEMPLATE_PARAMS
+    ) = (
+        'template_file', 'template_params'
+    )
+
+    properties_schema = {
+        TEMPLATE_FILE: properties.Schema(
+            properties.Schema.STRING,
+            _("Path of the Vitrage template to use."),
+            required=True,
+        ),
+        TEMPLATE_PARAMS: properties.Schema(
+            properties.Schema.MAP,
+            _("Input parameters for the Vitrage template."),
+            required=True,
+        ),
+    }
+
+    def handle_create(self):
+        """Create a Vitrage template."""
+
+        # Add the new template to Vitrage
+        params = self.properties[self.TEMPLATE_PARAMS]
+        params[self.TEMPLATE_NAME] = self.physical_resource_name()
+        params['description'] = self.properties.get('description')
+
+        LOG.debug('Vitrage params for template add: %s', params)
+
+        added_templates = self.client().template.add(
+            template_str=self.properties[self.TEMPLATE_FILE], params=params)
+
+        if added_templates and len(added_templates) > 0:
+            if added_templates[0].get('status') == 'LOADING':
+                self.resource_id_set(added_templates[0].get('uuid'))
+                LOG.debug('Added Vitrage template: %s',
+                          str(added_templates[0].get('uuid')))
+            else:
+                LOG.warning("Failed to add template to Vitrage: %s",
+                            added_templates[0].get('status details'))
+        else:
+            LOG.warning("Failed to add template to Vitrage")
+
+    def handle_delete(self):
+        """Delete the Vitrage template."""
+        if not self.resource_id:
+            return
+        LOG.debug('Deleting Vitrage template %s', self.resource_id)
+        self.client().template.delete(self.resource_id)
+
+    def validate(self):
+        """Validate a Vitrage template."""
+        super(VitrageTemplate, self).validate()
+
+        try:
+            params = self.properties[self.TEMPLATE_PARAMS]
+            params[self.TEMPLATE_NAME] = self.physical_resource_name()
+            params['description'] = self.properties.get('description')
+
+            for key, value in params.items():
+                if value is None:
+                    # some values depend on creation of other objects, which
+                    # was not done yet. Use temporary values for now.
+                    params[key] = 'temp'
+
+            LOG.debug('Vitrage params for template validate: %s', params)
+
+            validation = self.client().template.validate(
+                template_str=self.properties[self.TEMPLATE_FILE],
+                params=params)
+
+        except Exception as e:
+            msg = _("Exception when calling Vitrage template validate: %s") % \
+                e.message
+            raise exception.StackValidationFailed(message=msg)
+
+        if not validation or not validation.get('results') or \
+                len(validation['results']) != 1 or \
+                'status code' not in validation['results'][0]:
+            msg = _("Failed to validate Vitrage template %s") % \
+                self.TEMPLATE_FILE
+            raise exception.StackValidationFailed(message=msg)
+
+        result = validation['results'][0]
+        if result['status code'] != 0:
+            msg = _("Failed to validate Vitrage template. Error: %s") % \
+                result.get('message')
+            raise exception.StackValidationFailed(message=msg)
+
+
+def resource_mapping():
+    return {
+        'OS::Vitrage::Template': VitrageTemplate,
+    }
diff --git a/heat/tests/openstack/vitrage/__init__.py b/heat/tests/openstack/vitrage/__init__.py
new file mode 100644
index 000000000..e69de29bb
--- /dev/null
+++ b/heat/tests/openstack/vitrage/__init__.py
diff --git a/heat/tests/openstack/vitrage/test_vitrage_template.py b/heat/tests/openstack/vitrage/test_vitrage_template.py
new file mode 100644
index 000000000..7e83fbb4f
--- /dev/null
+++ b/heat/tests/openstack/vitrage/test_vitrage_template.py
@@ -0,0 +1,183 @@
+#
+#    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.
+
+from unittest import mock
+
+from heat.common import exception
+from heat.common import template_format
+from heat.engine.clients.os import mistral as mistral_client
+from heat.engine.resources.openstack.vitrage.vitrage_template import \
+    VitrageTemplate
+from heat.engine import scheduler
+from heat.tests import common
+from heat.tests import utils
+
+
+vitrage_template = '''
+heat_template_version: rocky
+resources:
+     execute_healing:
+       type: OS::Vitrage::Template
+       description: Execute Mistral healing workflow if instance is down
+       properties:
+         template_file: execute_healing_on_instance_down.yaml
+         template_params:
+           instance_alarm_name: Instance down
+           instance_id: 1233e48c-62ee-470e-8d4a-adff30211b5d
+           workflow_name: autoheal
+           heat_stack_id: 12cc6d3e-f801-4422-b2a0-43cedacb4eb5
+
+'''
+
+
+class TestVitrageTemplate(common.HeatTestCase):
+    def setUp(self):
+        super(TestVitrageTemplate, self).setUp()
+        self.ctx = utils.dummy_context()
+        template = template_format.parse(vitrage_template)
+        self.stack = utils.parse_stack(template, stack_name='test_stack')
+
+        resource_defs = self.stack.t.resource_definitions(self.stack)
+        self.resource_def = resource_defs['execute_healing']
+
+        self.vitrage = mock.Mock()
+        self.patchobject(VitrageTemplate, 'client', return_value=self.vitrage)
+
+        self.patches = []
+        self.patches.append(mock.patch.object(mistral_client,
+                                              'mistral_base'))
+        self.patches.append(mock.patch.object(
+            mistral_client.MistralClientPlugin, '_create'))
+        for patch in self.patches:
+            patch.start()
+
+        self.mistral_client = \
+            mistral_client.MistralClientPlugin(context=self.ctx)
+
+    def tearDown(self):
+        super(TestVitrageTemplate, self).tearDown()
+        for patch in self.patches:
+            patch.stop()
+
+    def test_create(self):
+        template = self._create_resource(
+            'execute_healing', self.resource_def, self.stack)
+        expected_state = (template.CREATE, template.COMPLETE)
+
+        # Verify the creation succeeded
+        self.assertEqual(expected_state, template.state)
+        self.assertEqual('2fddb683-e32c-4a9b-b8c8-df59af1f5a1a',
+                         template.get_reference_id())
+
+    def test_validate(self):
+        self.vitrage.template.validate.return_value = {
+            "results": [
+                {
+                    "status": "validation OK",
+                    "file path": "/tmp/tmpNUEgE3",
+                    "message": "Template validation is OK",
+                    "status code": 0,
+                    "description": "Template validation"
+                }
+            ]
+        }
+
+        # No result for a valid template
+        template = \
+            VitrageTemplate('execute_healing', self.resource_def, self.stack)
+        scheduler.TaskRunner(template.validate)()
+        self.vitrage.template.validate.assert_called_once()
+
+    def test_validate_vitrage_validate_wrong_format(self):
+        """wrong result format for vitrage templete validate"""
+        template = \
+            VitrageTemplate('execute_healing', self.resource_def, self.stack)
+
+        # empty return value
+        self.vitrage.template.validate.return_value = {}
+        self.assertRaises(exception.StackValidationFailed,
+                          scheduler.TaskRunner(template.validate))
+
+        # empty 'results'
+        self.vitrage.template.validate.return_value = {
+            "results": []
+        }
+        self.assertRaises(exception.StackValidationFailed,
+                          scheduler.TaskRunner(template.validate))
+
+        # too many 'results'
+        self.vitrage.template.validate.return_value = {
+            "results": [
+                {
+                    "status": "validation OK",
+                    "file path": "/tmp/tmpNUEgE3",
+                    "message": "Template validation is OK",
+                    "status code": 0,
+                    "description": "Template validation"
+                },
+                {
+                    "status": "validation OK",
+                    "file path": "/tmp/tmpNUEgE3",
+                    "message": "Template validation is OK",
+                    "status code": 0,
+                    "description": "Template validation"
+                },
+            ]
+        }
+        self.assertRaises(exception.StackValidationFailed,
+                          scheduler.TaskRunner(template.validate))
+
+        # no 'status code'
+        self.vitrage.template.validate.return_value = {
+            "results": [
+                {
+                    "status": "validation OK",
+                    "file path": "/tmp/tmpNUEgE3",
+                    "message": "Template validation is OK",
+                    "description": "Template validation"
+                }
+            ]
+        }
+        self.assertRaises(exception.StackValidationFailed,
+                          scheduler.TaskRunner(template.validate))
+
+    def test_validate_vitrage_validation_failed(self):
+        template = \
+            VitrageTemplate('execute_healing', self.resource_def, self.stack)
+
+        self.vitrage.template.validate.return_value = {
+            "results": [
+                {
+                    "status": "validation failed",
+                    "file path": "/tmp/tmpNUEgE3",
+                    "status code": 163,
+                    "message": "Failed to resolve parameter",
+                    "description": "Template content validation"
+                }
+            ]
+        }
+        self.assertRaises(exception.StackValidationFailed,
+                          scheduler.TaskRunner(template.validate))
+
+    def _create_resource(self, name, snippet, stack):
+        template = VitrageTemplate(name, snippet, stack)
+        self.vitrage.template.add.return_value = [{
+            'status': 'LOADING',
+            'uuid': '2fddb683-e32c-4a9b-b8c8-df59af1f5a1a',
+            'status details': 'Template validation is OK',
+            'date': '2019-02-20 16:36:17.240976',
+            'type': 'standard',
+            'name': 'Stack40-execute_healing-4ri7d3vlwp5w'
+        }]
+        scheduler.TaskRunner(template.create)()
+        return template
diff --git a/releasenotes/notes/vitrage-template-resource-8869a8e34418b22f.yaml b/releasenotes/notes/vitrage-template-resource-8869a8e34418b22f.yaml
new file mode 100644
index 000000000..012720c3b
--- /dev/null
+++ b/releasenotes/notes/vitrage-template-resource-8869a8e34418b22f.yaml
@@ -0,0 +1,6 @@
+---
+features:
+  - A new ``OS::Vitrage::Template`` resource is added to configure and create
+    a Vitrage template. The Vitrage template can be used, for example, for
+    executing a Mistral healing workflow in case there is an alarm on an
+    instance.