diff --git a/src/flow/lib/models/role.rb b/src/flow/lib/models/role.rb
index 6cfc29f619..ecfa69fe86 100644
--- a/src/flow/lib/models/role.rb
+++ b/src/flow/lib/models/role.rb
@@ -207,7 +207,8 @@ module OpenNebula
                     vm_state = node['vm_info']['VM']['STATE']
                     lcm_state = node['vm_info']['VM']['LCM_STATE']
 
-                    running = vm_state == '3' && lcm_state >= '3'
+                    running = (!Role.vm_failure?(vm_state, lcm_state) &&
+                                vm_state == '3' && lcm_state >= '3')
 
                     if running && @service.ready_status_gate
                         running_status = node['vm_info']['VM']['USER_TEMPLATE']['READY'] || ""
@@ -460,6 +461,35 @@ module OpenNebula
             end
         end
 
+        # Returns true if the VM state is failure
+        # @param [Integer] vm_state VM state
+        # @param [Integer] lcm_state VM LCM state
+        # @return [true,false] True if the lcm state is one of *_FAILURE
+        def self.vm_failure?(vm_state, lcm_state)
+            vm_state_str = VirtualMachine::VM_STATE[vm_state.to_i]
+            lcm_state_str = VirtualMachine::LCM_STATE[lcm_state.to_i]
+
+            if vm_state_str == 'ACTIVE' &&
+                (   lcm_state_str == 'BOOT_FAILURE' ||
+                    lcm_state_str == 'BOOT_MIGRATE_FAILURE' ||
+                    lcm_state_str == 'PROLOG_MIGRATE_FAILURE' ||
+                    lcm_state_str == 'PROLOG_FAILURE' ||
+                    lcm_state_str == 'EPILOG_FAILURE' ||
+                    lcm_state_str == 'EPILOG_STOP_FAILURE' ||
+                    lcm_state_str == 'EPILOG_UNDEPLOY_FAILURE' ||
+                    lcm_state_str == 'PROLOG_MIGRATE_POWEROFF_FAILURE' ||
+                    lcm_state_str == 'PROLOG_MIGRATE_SUSPEND_FAILURE' ||
+                    lcm_state_str == 'BOOT_UNDEPLOY_FAILURE' ||
+                    lcm_state_str == 'BOOT_STOPPED_FAILURE' ||
+                    lcm_state_str == 'PROLOG_RESUME_FAILURE' ||
+                    lcm_state_str == 'PROLOG_UNDEPLOY_FAILURE')
+
+                return true
+            end
+
+            return false
+        end
+
         ########################################################################
         # Scalability
         ########################################################################
@@ -848,23 +878,7 @@ module OpenNebula
                     # Store the VM id in the array of disposed nodes
                     disposed_nodes << vm_id
 
-                elsif ( vm_state_str == 'FAILED' ||
-                        vm_state_str == 'ACTIVE' &&
-                        (   lcm_state_str == 'FAILURE' ||
-                            lcm_state_str == 'BOOT_FAILURE' ||
-                            lcm_state_str == 'BOOT_MIGRATE_FAILURE' ||
-                            lcm_state_str == 'PROLOG_MIGRATE_FAILURE' ||
-                            lcm_state_str == 'PROLOG_FAILURE' ||
-                            lcm_state_str == 'EPILOG_FAILURE' ||
-                            lcm_state_str == 'EPILOG_STOP_FAILURE' ||
-                            lcm_state_str == 'EPILOG_UNDEPLOY_FAILURE' ||
-                            lcm_state_str == 'PROLOG_MIGRATE_POWEROFF_FAILURE' ||
-                            lcm_state_str == 'PROLOG_MIGRATE_SUSPEND_FAILURE' ||
-                            lcm_state_str == 'PROLOG_UNDEPLOY_FAILURE' ||
-                            lcm_state_str == 'PROLOG_RESUME_FAILURE' ||
-                            lcm_state_str == 'BOOT_UNDEPLOY_FAILURE' ||
-                            lcm_state_str == 'BOOT_STOPPED_FAILURE' ))
-
+                elsif ( Role.vm_failure?(vm_state, lcm_state) )
                     vm = OpenNebula::VirtualMachine.new_with_id(vm_id, @service.client)
                     rc = vm.finalize
 
diff --git a/src/flow/lib/strategy.rb b/src/flow/lib/strategy.rb
index 4dc3a89341..02c95ca50b 100644
--- a/src/flow/lib/strategy.rb
+++ b/src/flow/lib/strategy.rb
@@ -276,24 +276,8 @@ protected
                 vm_state = node['vm_info']['VM']['STATE']
                 lcm_state = node['vm_info']['VM']['LCM_STATE']
 
-                if vm_state == '7' ||            # FAILED
-                    (vm_state == '3' &&          # ACTIVE
-                        (   lcm_state == '14' || # FAILURE
-                            lcm_state == '16' || # UNKNOWN
-                            lcm_state == '36' || # BOOT_FAILURE
-                            lcm_state == '37' || # BOOT_MIGRATE_FAILURE
-                            lcm_state == '38' || # PROLOG_MIGRATE_FAILURE
-                            lcm_state == '39' || # PROLOG_FAILURE
-                            lcm_state == '40' || # EPILOG_FAILURE
-                            lcm_state == '41' || # EPILOG_STOP_FAILURE
-                            lcm_state == '42' || # EPILOG_UNDEPLOY_FAILURE
-                            lcm_state == '44' || # PROLOG_MIGRATE_POWEROFF_FAILURE
-                            lcm_state == '46' || # PROLOG_MIGRATE_SUSPEND_FAILURE
-                            lcm_state == '47' || # BOOT_UNDEPLOY_FAILURE
-                            lcm_state == '48' || # BOOT_STOPPED_FAILURE
-                            lcm_state == '49' || # PROLOG_RESUME_FAILURE
-                            lcm_state == '50' )  # PROLOG_UNDEPLOY_FAILURE
-                    )
+                # Failure or UNKNOWN
+                if vm_failure?(node) || (vm_state == '3' && lcm_state == '16')
                     return true
                 end
             end
@@ -307,12 +291,8 @@ protected
     # @return [true|false]
     def any_node_failed?(role)
         role.get_nodes.each { |node|
-            if node && node['vm_info']
-                vm_state = node['vm_info']['VM']['STATE']
-
-                if vm_state == '7' # FAILED
-                    return true
-                end
+            if vm_failure?(node)
+                return true
             end
         }
 
@@ -343,9 +323,9 @@ protected
     # @return [true|false]
     def any_node_failed_scaling?(role)
         role.get_nodes.each { |node|
-            if node && node['vm_info'] &&
+            if  node && node['vm_info'] &&
                 (node['disposed'] == '1' || node['scale_up'] == '1') &&
-                node['vm_info']['VM']['STATE'] == '7' # FAILED
+                vm_failure?(node)
 
                 return true
             end
@@ -372,4 +352,14 @@ protected
         # For scale down, it will finish when scaling nodes are deleted
         return role.get_nodes.size() == role.cardinality()
     end
+
+    def vm_failure?(node)
+        if node && node['vm_info']
+            return Role.vm_failure?(
+                vm_state = node['vm_info']['VM']['STATE'],
+                lcm_state = node['vm_info']['VM']['LCM_STATE'])
+        end
+
+        return false
+    end
 end