Add instance restarter

Change-Id: I8ef28efc7d86a1a3a44f4784cb496c415a14f95c
Signed-off-by: Angus Salkeld <asalkeld@redhat.com>

heat/engine/instance.py

@@ -46,6 +46,34 @@ else:
             break
 
 
+class Restarter(Resource):
+    properties_schema = {'InstanceId': {'Type': 'String',
+                                        'Required': True}}
+
+    def __init__(self, name, json_snippet, stack):
+        super(Restarter, self).__init__(name, json_snippet, stack)
+
+    def create(self):
+        if self.state != None:
+            return
+        self.state_set(self.CREATE_IN_PROGRESS)
+        Resource.create(self)
+        self.state_set(self.CREATE_COMPLETE)
+
+    def delete(self):
+        if self.state == self.DELETE_IN_PROGRESS or \
+           self.state == self.DELETE_COMPLETE:
+            return
+        self.state_set(self.DELETE_IN_PROGRESS)
+        Resource.delete(self)
+        self.state_set(self.DELETE_COMPLETE)
+
+    def alarm(self):
+        logger.notice('%s Alarm, restarting resource: %s' % \
+                      (self.name, self.properties['InstanceId']))
+        self.stack.restart_resource(self.properties['InstanceId'])
+
+
 class Instance(Resource):
     # AWS does not require KeyName and InstanceType but we seem to
     properties_schema = {'ImageId': {'Type': 'String',

heat/engine/parser.py

@@ -47,6 +47,7 @@ logger = logging.getLogger(__file__)
     'AWS::CloudFormation::WaitCondition': wait_condition.WaitCondition,
     'AWS::IAM::User': user.User,
     'AWS::IAM::AccessKey': user.AccessKey,
+    'HEAT::HA::Restarter': instance.Restarter,
 },)
 
 
@@ -278,6 +279,48 @@ class Stack(object):
 
         return outs
 
+    def restart_resource_blocking(self, resource_name):
+        '''
+        stop resource_name and all that depend on it
+        start resource_name and all that depend on it
+        '''
+        order = []
+        self.resource_append_deps(self.resources[resource_name], order)
+
+        for r in reversed(order):
+            res = self.resources[r]
+            try:
+                res.delete()
+                #db_api.resource_get(None, self.resources[r].id).delete()
+            except Exception as ex:
+                failed = True
+                res.state_set(res.DELETE_FAILED)
+                logger.error('delete: %s' % str(ex))
+
+        for r in order:
+            res = self.resources[r]
+            if not failed:
+                try:
+                    res.create()
+                except Exception as ex:
+                    logger.exception('create')
+                    failed = True
+                    res.state_set(res.CREATE_FAILED, str(ex))
+
+                try:
+                    self.update_parsed_template()
+                except Exception as ex:
+                    logger.exception('update_parsed_template')
+
+            else:
+                res.state_set(res.CREATE_FAILED)
+        # TODO(asalkeld) if any of this fails we Should
+        # restart the whole stack
+
+    def restart_resource(self, resource_name):
+        pool = eventlet.GreenPool()
+        pool.spawn_n(self.restart_resource_blocking)
+
     def calulate_dependencies(self, s, r):
         if isinstance(s, dict):
             for i in s:

templates/WordPress_Single_Instance_With_HA.template

@@ -98,9 +98,9 @@
 
   "Resources" : {
     "WebServerRestartPolicy" : {
-      "Type" : "HEAT::Recovery::EscalationPolicy",
+      "Type" : "HEAT::HA::Restarter",
       "Properties" : {
-        "Instance" : { "Ref" : "WikiDatabase" }
+        "InstanceId" : { "Ref" : "WikiDatabase" }
       }
     },
     "HttpFailureAlarm": {